projects / deliverable / titan.core.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Sync with 5.4.0
[deliverable/titan.core.git] / function_test / Text_EncDec / TEXT_1_TD.script
1 .******************************************************************************
2 .* Copyright (c) 2000-2015 Ericsson Telecom AB
3 .* All rights reserved. This program and the accompanying materials
4 .* are made available under the terms of the Eclipse Public License v1.0
5 .* which accompanies this distribution, and is available at
6 .* http://www.eclipse.org/legal/epl-v10.html
7 .******************************************************************************/
8 :text.
9 :lang eng.
10 .*
11 :docname.Test Description
12 :docno.21/152 91-CRL 113 200/3 Uen
13 :rev.A
14 :date.2013-01-17
15 .*
16 :prep.ETH/XZR Krisztian Pandi
17 :appr.ETH/XZ (Gyula Koos)
18 :checked.ETHGRY
19 .*
20 :title.Test Description - Text based coding for TTCN-3 Test Executor
21 :contents level=3.
22 .*---------------------------------------------------------------------*
23 :h1.PREREQUISITES AND PREPARATIONS
24 .*---------------------------------------------------------------------*
25 .*---------------------------------------------------------------------*
26 :h2.Scope of the Test Object
27 .*---------------------------------------------------------------------*
28 :xmp tab=1 nokeep.
29
30 This file is obsolate, don't modify, improve it anymore!
31
32 This TD contains test cases related to TTCN3 Executor's Text coder function.
33 A faster version is located in the TEXT_1_TD.fast_script file.
34 DON'T YOU DARE TO WRITE AN INSPECTION RECORD ABOUT THIS FILE.
35
36 :exmp.
37
38 :p.:us.Revision Information:eus.
39
40 :xmp nokeep.
41 :us.History:eus.
42
43 REV DATE PREPARED CHANGE
44 === ========== ======== ======
45 A 2005-01-10 ETHGHASZ New document
46 B 2005-10-11 EKRISZA Updated for group support.
47 C 2007-03-06 EDMDELI Implicit message encoding
48 D 2008-10-01 EFERKOV Big integers
49 E 2011-01-24 EKRISZA Restructured to use more efficient script.
50 F 2011-10-10 EKRISZA Updated for release.
51 A 2011-12-12 EKRISZA Updated for release
52 A 2012-06-27 EFERKOV Updated for release
53 A 2013-01-17 EKRIPND Updated for release
54 :exmp.
55
56 .*---------------------------------------------------------------------*
57 :h1.Test environment
58 .*---------------------------------------------------------------------*
59 .*---------------------------------------------------------------------*
60 :h2.Hardware
61 .*---------------------------------------------------------------------*
62 No specific hardware requirement.
63 .*---------------------------------------------------------------------*
64 :h2.Software
65 .*---------------------------------------------------------------------*
66 Tests shall be carried out on the following platforms:
67 :list.
68 :li D='1.'.Solaris 8 (Sun OS 5.8) (gcc 3.0.4)
69 :li D='2.'.SUSE Linux Enterprise server 8 (2.4.19-4GB) (gcc 3.2)
70 :li D='3.'.CYGWIN_NT-5.0 (Cygwin DLL: 1.5.12) on Windows 2000 (gcc 3.3.3)
71 :elist.
72 .*---------------------------------------------------------------------*
73 :h2.Configuration
74 .*---------------------------------------------------------------------*
75 The test environment had been setup in CVS. The tester program is stored in:
76 :nl.TTCNv3/function_test/Tools/SAtester.pl
77 :nl.Test cases are stored with extension .script in the directory:
78 :nl.TTCNv3/function_test/Semantic_Analyser/
79 .*---------------------------------------------------------------------*
80 :h2.Installation
81 .*---------------------------------------------------------------------*
82 Install proper TITAN binaries on the used platforms and make sure that
83 your environment settings are correct:
84 :list.
85 :li D='1.'.TTCN3_DIR is set
86 :li D='2.'.$TTCN3_DIR/bin is added to the PATH variable
87 :li D='3.'.$TTCN3_DIR/lib is added to the LD_LIBRARY_PATH variable
88 :li D='4.'.Perl 5.6.0 or higher is available on the platform
89 :li D='5.'.Create a symlink to your Perl binary into the directory where the
90 test cases are stored:
91 :nl.ln -s <your Perl> perl
92 :elist.
93 .*---------------------------------------------------------------------*
94 :h2.Test Tools
95 .*---------------------------------------------------------------------*
96 :p.Test cases are specified in the Test Description documents in EDML format.
97 The tester program parses these files and generates the TTCN-3/ASN.1 modules, then
98 calls the compiler to compile them. The result printout is then matched against
99 different patterns to be able to set the verdict. Test cases contain not only
100 the source modules, but the patterns as well.
101 :p.The tester program allows one-by-one execution of test cases and batched
102 execution as well.
103 :p.NOTE: the tester program requires Perl 5.6.0 or higher.
104 .*---------------------------------------------------------------------*
105 :h1.REQUIREMENT-BASED TESTS
106 .*---------------------------------------------------------------------*
107 .*---------------------------------------------------------------------*
108 :h2.Basic types - Charstring
109 .*---------------------------------------------------------------------*
110 This test case group covers the encoding attributes of type charstring
111 .*---------------------------------------------------------------------*
112 :h3.Length
113 .*---------------------------------------------------------------------*
114 :xmp tab=0.
115
116 <TC - Fixed length encoding>
117
118 <STATIC>
119
120 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
121 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
122
123 group TEXT_group{
124
125 type charstring TEXT_PDU with { variant "TEXT_CODING(length=5)"};
126
127 } with {encode "TEXT"}
128
129 const TEXT_PDU i := "HALI"
130 const charstring o := " HALI"
131 const TEXT_PDU expected_res:=" HALI"
132
133 <TTCN_TC:EXEC>
134 var charstring res:=enc_TEXT_PDU(i);
135 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
136
137 if( res==o and dec_pdu==expected_res){
138 setverdict(pass);
139 } else {
140 log ("enc_TEXT_PDU(i)= " , res) ;
141 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
142 setverdict(fail);}
143
144 <RESULT>
145 Overall verdict: pass
146 <END_TC>
147
148 :exmp.
149
150
151 .*---------------------------------------------------------------------*
152 :h3.Convert
153 .*---------------------------------------------------------------------*
154 :xmp tab=0.
155
156 <TC - Convert string to lower case during encoding>
157
158 <STATIC>
159
160 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
161 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
162
163 group TEXT_group{
164
165 type charstring TEXT_PDU with { variant "TEXT_CODING(convert=lower_case)"};
166
167 } with {encode "TEXT"}
168
169 const TEXT_PDU i := "HALI"
170 const charstring o := "hali"
171 const TEXT_PDU expected_res:="hali"
172
173 <TTCN_TC:EXEC>
174 var charstring res:=enc_TEXT_PDU(i);
175 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
176
177 if( res==o and dec_pdu==expected_res){
178 setverdict(pass);
179 } else {
180 log ("enc_TEXT_PDU(i)= " , res) ;
181 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
182 setverdict(fail);}
183
184 <RESULT>
185 Overall verdict: pass
186 <END_TC>
187
188 :exmp.
189
190 :xmp tab=0.
191
192 <TC - Convert string to upper case during encoding>
193
194 <STATIC>
195
196 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
197 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
198
199 group TEXT_group{
200
201 type charstring TEXT_PDU with { variant "TEXT_CODING(convert=upper_case)"};
202
203 } with {encode "TEXT"}
204
205 const TEXT_PDU i := "hali"
206 const charstring o := "HALI"
207 const TEXT_PDU expected_res:="HALI"
208
209 <TTCN_TC:EXEC>
210 var charstring res:=enc_TEXT_PDU(i);
211 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
212
213 if( res==o and dec_pdu==expected_res){
214 setverdict(pass);
215 } else {
216 log ("enc_TEXT_PDU(i)= " , res) ;
217 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
218 setverdict(fail);}
219
220 <RESULT>
221 Overall verdict: pass
222 <END_TC>
223
224 :exmp.
225
226 :xmp tab=0.
227
228 <TC - Convert string to lower case during encoding and upper case during decoding>
229
230 <STATIC>
231
232 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
233 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
234
235 group TEXT_group{
236
237 type charstring TEXT_PDU with { variant "TEXT_CODING(convert=lower_case,
238 convert=upper_case)"};
239
240 } with {encode "TEXT"}
241
242 const TEXT_PDU i:="HALI"
243 const charstring o := "hali"
244 const TEXT_PDU expected_res:="HALI"
245
246 <TTCN_TC:EXEC>
247 var charstring res:=enc_TEXT_PDU(i);
248 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
249
250 if( res==o and dec_pdu==expected_res){
251 setverdict(pass);
252 } else {
253 log ("enc_TEXT_PDU(i)= " , res) ;
254 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
255 setverdict(fail);}
256
257 <RESULT>
258 Overall verdict: pass
259 <END_TC>
260
261 :exmp.
262
263
264 :xmp tab=0.
265
266 <TC - Convert string to upper case during encoding and lower case during decoding>
267
268 <STATIC>
269
270 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
271 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
272
273 group TEXT_group{
274
275 type charstring TEXT_PDU with { variant "TEXT_CODING(convert=upper_case,
276 convert=lower_case)"};
277
278 } with {encode "TEXT"}
279
280 const TEXT_PDU i:="hali"
281 const charstring o := "HALI"
282 const TEXT_PDU expected_res:="hali"
283
284 <TTCN_TC:EXEC>
285 var charstring res:=enc_TEXT_PDU(i);
286 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
287
288 if( res==o and dec_pdu==expected_res){
289 setverdict(pass);
290 } else {
291 log ("enc_TEXT_PDU(i)= " , res) ;
292 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
293 setverdict(fail);}
294
295 <RESULT>
296 Overall verdict: pass
297 <END_TC>
298
299 :exmp.
300 .*---------------------------------------------------------------------*
301 :h3.Justification
302 .*---------------------------------------------------------------------*
303
304 :xmp tab=0.
305
306 <TC - Left justification>
307
308 <STATIC>
309
310 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
311 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
312
313 group TEXT_group{
314
315 type charstring TEXT_PDU with { variant "TEXT_CODING(just=left;length=5)"};
316
317 } with {encode "TEXT"}
318
319 const TEXT_PDU i:="hali"
320 const charstring o := "hali "
321 const TEXT_PDU expected_res:="hali "
322
323 <TTCN_TC:EXEC>
324 var charstring res:=enc_TEXT_PDU(i);
325 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
326
327 if( res==o and dec_pdu==expected_res){
328 setverdict(pass);
329 } else {
330 log ("enc_TEXT_PDU(i)= " , res) ;
331 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
332 setverdict(fail);}
333
334 <RESULT>
335 Overall verdict: pass
336 <END_TC>
337
338 :exmp.
339
340 :xmp tab=0.
341
342 <TC - Center justification>
343
344 <STATIC>
345
346 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
347 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
348
349 group TEXT_group{
350
351 type charstring TEXT_PDU with { variant "TEXT_CODING(just=center;length=6)"};
352
353 } with {encode "TEXT"}
354
355 const TEXT_PDU i:="hali"
356 const charstring o := " hali "
357 const TEXT_PDU expected_res:=" hali "
358
359 <TTCN_TC:EXEC>
360 var charstring res:=enc_TEXT_PDU(i);
361 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
362
363 if( res==o and dec_pdu==expected_res){
364 setverdict(pass);
365 } else {
366 log ("enc_TEXT_PDU(i)= " , res) ;
367 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
368 setverdict(fail);}
369
370 <RESULT>
371 Overall verdict: pass
372 <END_TC>
373
374 :exmp.
375
376 :xmp tab=0.
377
378 <TC - Right justification>
379 <STATIC>
380
381 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
382 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
383
384 group TEXT_group{
385
386 type charstring TEXT_PDU with { variant "TEXT_CODING(just=right;length=5)"};
387
388 } with {encode "TEXT"}
389
390 const TEXT_PDU i:="hali"
391 const charstring o := " hali"
392 const TEXT_PDU expected_res:=" hali"
393
394 <TTCN_TC:EXEC>
395 var charstring res:=enc_TEXT_PDU(i);
396 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
397
398 if( res==o and dec_pdu==expected_res){
399 setverdict(pass);
400 } else {
401 log ("enc_TEXT_PDU(i)= " , res) ;
402 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
403 setverdict(fail);}
404
405 <RESULT>
406 Overall verdict: pass
407 <END_TC>
408 :exmp.
409 .*---------------------------------------------------------------------*
410 :h3.Select token
411 .*---------------------------------------------------------------------*
412 :xmp tab=0.
413
414 <TC - Case sensitive selection>
415 <STATIC>
416
417 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
418 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
419
420 group TEXT_group{
421
422 type charstring TEXT_PDU with { variant "TEXT_CODING(,,'[\d]#(4)[a-e]#(4)')"};
423
424 } with {encode "TEXT"}
425
426 const TEXT_PDU i:="1234abcd"
427 const charstring o := "1234abcdfrd"
428 const TEXT_PDU expected_res:="1234abcd"
429 <TTCN_TC:EXEC>
430 var charstring res:=enc_TEXT_PDU(i);
431 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
432
433 if(dec_pdu==expected_res){
434 setverdict(pass);
435 } else {
436 log ("enc_TEXT_PDU(i)= " , res) ;
437 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
438 setverdict(fail);}
439
440 <RESULT>
441 Overall verdict: pass
442 <END_TC>
443
444 :exmp.
445 :xmp tab=0.
446
447 <TC - Case insensitive selection>
448 <STATIC>
449
450 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
451 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
452
453 group TEXT_group{
454
455 type charstring TEXT_PDU with { variant "TEXT_CODING(,convert=lower_case,
456 '[\d]#(4)[a-e]#(4)', case_insensitive)"};
457
458 } with {encode "TEXT"}
459
460 const TEXT_PDU i:="1234abcd"
461 const charstring o := "1234aBCdfrd"
462 const TEXT_PDU expected_res:="1234abcd"
463
464 <TTCN_TC:EXEC>
465 var charstring res:=enc_TEXT_PDU(i);
466 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
467
468 if(dec_pdu==expected_res){
469 setverdict(pass);
470 } else {
471 log ("enc_TEXT_PDU(i)= " , res) ;
472 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
473 setverdict(fail);}
474
475 <RESULT>
476 Overall verdict: pass
477 <END_TC>
478
479 :exmp.
480 .*---------------------------------------------------------------------*
481 :h2.Basic types - Integer
482 .*---------------------------------------------------------------------*
483 .*---------------------------------------------------------------------*
484 :h3.Length
485 .*---------------------------------------------------------------------*
486 :xmp tab=0.
487
488 <TC - Fixed length>
489 <STATIC>
490
491 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
492 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
493
494 group TEXT_group{
495
496 type integer TEXT_PDU with { variant "TEXT_CODING(length=5)"};
497
498 } with {encode "TEXT"}
499
500 const TEXT_PDU i:=249
501 const charstring o := " 249"
502 const TEXT_PDU expected_res:=249
503
504 <TTCN_TC:EXEC>
505 var charstring res:=enc_TEXT_PDU(i);
506 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
507
508 if( res==o and dec_pdu==expected_res){
509 setverdict(pass);
510 } else {
511 log ("enc_TEXT_PDU(i)= " , res) ;
512 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
513 setverdict(fail);}
514
515 <RESULT>
516 Overall verdict: pass
517 <END_TC>
518
519 :exmp.
520 :xmp tab=0.
521
522 <TC - variable length>
523 <STATIC>
524
525 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
526 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
527
528 group TEXT_group{
529
530 type integer TEXT_PDU with { variant "TEXT_CODING()"};
531
532 } with {encode "TEXT"}
533
534 const TEXT_PDU i:=12249
535 const charstring o := "12249"
536 const TEXT_PDU expected_res:=12249
537
538 <TTCN_TC:EXEC>
539 var charstring res:=enc_TEXT_PDU(i);
540 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
541
542 if( res==o and dec_pdu==expected_res){
543 setverdict(pass);
544 } else {
545 log ("enc_TEXT_PDU(i)= " , res) ;
546 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
547 setverdict(fail);}
548
549 <RESULT>
550 Overall verdict: pass
551 <END_TC>
552
553 :exmp.
554 .*---------------------------------------------------------------------*
555 :h3.Leading zero's
556 .*---------------------------------------------------------------------*
557 :xmp tab=0.
558
559 <TC - encoding without leading zero>
560 <STATIC>
561
562 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
563 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
564
565 group TEXT_group{
566
567 type integer TEXT_PDU with { variant "TEXT_CODING(length=7)"};
568
569 } with {encode "TEXT"}
570
571 const TEXT_PDU i:=12249
572 const charstring o := " 12249"
573 const TEXT_PDU expected_res:=12249
574
575 <TTCN_TC:EXEC>
576 var charstring res:=enc_TEXT_PDU(i);
577 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
578
579 if( res==o and dec_pdu==expected_res){
580 setverdict(pass);
581 } else {
582 log ("enc_TEXT_PDU(i)= " , res) ;
583 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
584 setverdict(fail);}
585
586 <RESULT>
587 Overall verdict: pass
588 <END_TC>
589
590 :exmp.
591 :xmp tab=0.
592
593 <TC - encoding with leading zero>
594 <STATIC>
595
596 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
597 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
598
599 group TEXT_group{
600
601 type integer TEXT_PDU with { variant "TEXT_CODING(leading0=true;length=7)"};
602
603 } with {encode "TEXT"}
604
605 const TEXT_PDU i:=12249
606 const charstring o := "0012249"
607 const TEXT_PDU expected_res:=12249
608
609 <TTCN_TC:EXEC>
610 var charstring res:=enc_TEXT_PDU(i);
611 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
612
613 if( res==o and dec_pdu==expected_res){
614 setverdict(pass);
615 } else {
616 log ("enc_TEXT_PDU(i)= " , res) ;
617 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
618 setverdict(fail);}
619
620 <RESULT>
621 Overall verdict: pass
622 <END_TC>
623
624 :exmp.
625 :xmp tab=0.
626
627 <TC - encoding negativ integer with leading zero>
628 <STATIC>
629
630 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
631 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
632
633 group TEXT_group{
634
635 type integer TEXT_PDU with { variant "TEXT_CODING(leading0=true;length=7)"};
636
637 } with {encode "TEXT"}
638
639 const TEXT_PDU i:=-12249
640 const charstring o := "-012249"
641 const TEXT_PDU expected_res:=-12249
642
643 <TTCN_TC:EXEC>
644 var charstring res:=enc_TEXT_PDU(i);
645 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
646
647 if( res==o and dec_pdu==expected_res){
648 setverdict(pass);
649 } else {
650 log ("enc_TEXT_PDU(i)= " , res) ;
651 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
652 setverdict(fail);}
653
654 <RESULT>
655 Overall verdict: pass
656 <END_TC>
657
658 :exmp.
659 .*---------------------------------------------------------------------*
660 :h3.Select token
661 .*---------------------------------------------------------------------*
662 :xmp tab=0.
663
664 <TC - Selection of integer value>
665 <STATIC>
666
667 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
668 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
669
670 group TEXT_group{
671
672 type integer TEXT_PDU with { variant "TEXT_CODING(,,
673 '[1-4]#(1,)')"};
674
675 } with {encode "TEXT"}
676
677 const TEXT_PDU i:=123423
678 const charstring o := "123423567aBCdfrd"
679 const TEXT_PDU expected_res:=123423
680
681 <TTCN_TC:EXEC>
682 var charstring res:=enc_TEXT_PDU(i);
683 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
684
685 if(dec_pdu==expected_res){
686 setverdict(pass);
687 } else {
688 log ("enc_TEXT_PDU(i)= " , res) ;
689 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
690 setverdict(fail);}
691
692 <RESULT>
693 Overall verdict: pass
694 <END_TC>
695 :exmp.
696
697 .*---------------------------------------------------------------------*
698 :h2.Basic types - Boolean
699 .*---------------------------------------------------------------------*
700 :xmp tab=0.
701
702 <TC - Basic encoding of true value>
703 <STATIC>
704
705 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
706 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
707
708 group TEXT_group{
709
710 type boolean TEXT_PDU with { variant "TEXT_CODING()"};
711
712 } with {encode "TEXT"}
713
714 const TEXT_PDU i:=true
715 const charstring o := "true"
716 const TEXT_PDU expected_res:=true
717
718 <TTCN_TC:EXEC>
719 var charstring res:=enc_TEXT_PDU(i);
720 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
721
722 if( res==o and dec_pdu==expected_res){
723 setverdict(pass);
724 } else {
725 log ("enc_TEXT_PDU(i)= " , res) ;
726 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
727 setverdict(fail);}
728
729 <RESULT>
730 Overall verdict: pass
731 <END_TC>
732
733 :exmp.
734 :xmp tab=0.
735
736 <TC - Basic encoding of false value>
737 <STATIC>
738
739 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
740 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
741
742 group TEXT_group{
743
744 type boolean TEXT_PDU with { variant "TEXT_CODING()"};
745
746 } with {encode "TEXT"}
747
748 const TEXT_PDU i:=false
749 const charstring o := "false"
750 const TEXT_PDU expected_res:=false
751
752 <TTCN_TC:EXEC>
753 var charstring res:=enc_TEXT_PDU(i);
754 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
755
756 if( res==o and dec_pdu==expected_res){
757 setverdict(pass);
758 } else {
759 log ("enc_TEXT_PDU(i)= " , res) ;
760 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
761 setverdict(fail);}
762
763 <RESULT>
764 Overall verdict: pass
765 <END_TC>
766
767 :exmp.
768 :xmp tab=0.
769
770 <TC - Encoding and decoding of given tokens 1>
771 <STATIC>
772
773 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
774 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
775
776 group TEXT_group{
777
778 type boolean TEXT_PDU with { variant "TEXT_CODING(true:'YES';false:'NO')"};
779
780 } with {encode "TEXT"}
781
782 const TEXT_PDU i:=false
783 const charstring o := "NO"
784 const TEXT_PDU expected_res:=false
785
786 <TTCN_TC:EXEC>
787 var charstring res:=enc_TEXT_PDU(i);
788 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
789
790 if( res==o and dec_pdu==expected_res){
791 setverdict(pass);
792 } else {
793 log ("enc_TEXT_PDU(i)= " , res) ;
794 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
795 setverdict(fail);}
796
797 <RESULT>
798 Overall verdict: pass
799 <END_TC>
800
801 :exmp.
802 :xmp tab=0.
803
804 <TC - Encoding and decoding of given tokens 2>
805 <STATIC>
806
807 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
808 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
809
810 group TEXT_group{
811
812 type boolean TEXT_PDU with { variant "TEXT_CODING(true:'YES';false:'NO',
813 true:'good';false:{'bad',case_insensitive})"};
814
815 } with {encode "TEXT"}
816
817 const TEXT_PDU i:=false
818 const charstring o1 := "NO"
819 const charstring o := "Bad"
820 const TEXT_PDU expected_res:=false
821
822 <TTCN_TC:EXEC>
823 var charstring res:=enc_TEXT_PDU(i);
824 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
825
826 if( res==o1 and dec_pdu==expected_res){
827 setverdict(pass);
828 } else {
829 log ("enc_TEXT_PDU(i)= " , res) ;
830 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
831 setverdict(fail);}
832
833 <RESULT>
834 Overall verdict: pass
835 <END_TC>
836
837 :exmp.
838 .*---------------------------------------------------------------------*
839 :h2.Basic types - Enumerated
840 .*---------------------------------------------------------------------*
841 :xmp tab=0.
842
843 <TC - Basic encoding of enumerated values>
844 <STATIC>
845
846 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
847 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
848
849 group TEXT_group{
850
851 type enumerated TEXT_PDU {egy,ketto,harom}
852 with { variant "TEXT_CODING()"};
853
854 } with {encode "TEXT"}
855
856 <TTCN_TC:EXEC>
857 var TEXT_PDU i:=egy
858 var charstring o := "egy"
859 var TEXT_PDU expected_res:=egy
860 var charstring res:=enc_TEXT_PDU(i);
861 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
862
863 if( res==o and dec_pdu==expected_res){
864 setverdict(pass);
865 } else {setverdict(fail);}
866
867 i:=harom
868 o := "harom"
869 expected_res:=harom
870 res:=enc_TEXT_PDU(i);
871 dec_pdu:=dec_TEXT_PDU(o);
872
873 if( res==o and dec_pdu==expected_res){
874 setverdict(pass);
875 } else {setverdict(fail);}
876
877 <RESULT>
878 Overall verdict: pass
879 <END_TC>
880
881 :exmp.
882 :xmp tab=0.
883
884 <TC - Encoding of given enumerated values>
885 <STATIC>
886
887 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
888 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
889
890 group TEXT_group{
891
892 type enumerated TEXT_PDU {egy,ketto,harom}
893 with { variant "TEXT_CODING(egy:'haho';harom:'har',
894 egy:'(haho)|(H)';ketto:{,case_insensitive};
895 harom:{'hArom',case_insensitive})"};
896
897 } with {encode "TEXT"}
898
899 <TTCN_TC:EXEC>
900 var TEXT_PDU i:=egy
901 var charstring o := "haho"
902 var charstring o1 := "H"
903 var TEXT_PDU expected_res:=egy
904 var charstring res:=enc_TEXT_PDU(i);
905 var TEXT_PDU dec_pdu2:=dec_TEXT_PDU(o1);
906 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
907
908 if( res==o and dec_pdu==expected_res and dec_pdu2==expected_res){
909 setverdict(pass);
910 } else {setverdict(fail);}
911
912 i:=ketto
913 o := "ketto"
914 o1:="KettO"
915 expected_res:=ketto
916 res:=enc_TEXT_PDU(i);
917 dec_pdu:=dec_TEXT_PDU(o1);
918
919 if( res==o and dec_pdu==expected_res){
920 setverdict(pass);
921 } else {setverdict(fail);}
922
923 i:=harom
924 o := "har"
925 o1:="haRoM"
926 expected_res:=harom
927 res:=enc_TEXT_PDU(i);
928 dec_pdu:=dec_TEXT_PDU(o1);
929
930 if( res==o and dec_pdu==expected_res){
931 setverdict(pass);
932 } else {setverdict(fail);}
933
934 <RESULT>
935 Overall verdict: pass
936 <END_TC>
937
938 :exmp.
939 .*---------------------------------------------------------------------*
940 :h2.Leading, separation and trailing token
941 .*---------------------------------------------------------------------*
942 .*---------------------------------------------------------------------*
943 :h3.Leading token
944 .*---------------------------------------------------------------------*
945 :xmp tab=0.
946
947 <TC - Coding with leading token>
948 <STATIC>
949
950 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
951 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
952
953 group TEXT_group{
954
955 type charstring TEXT_PDU with { variant "BEGIN('Header:')"};
956
957 } with {encode "TEXT"}
958
959 const TEXT_PDU i:="value"
960 const charstring o := "Header:value"
961 const TEXT_PDU expected_res:="value"
962 <TTCN_TC:EXEC>
963 var charstring res:=enc_TEXT_PDU(i);
964 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
965
966 if( res==o and dec_pdu==expected_res){
967 setverdict(pass);
968 } else {
969 log ("enc_TEXT_PDU(i)= " , res) ;
970 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
971 setverdict(fail);}
972
973 <RESULT>
974 Overall verdict: pass
975 <END_TC>
976 :exmp.
977 :xmp tab=0.
978
979 <TC - Coding with leading token, case insensitive decoding>
980 <STATIC>
981
982 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
983 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
984
985 group TEXT_group{
986
987 type charstring TEXT_PDU with { variant "BEGIN('Header:',, case_insensitive)"};
988
989 } with {encode "TEXT"}
990
991 const TEXT_PDU i:="value"
992 const charstring o := "heADer:value"
993 const TEXT_PDU expected_res:="value"
994 <TTCN_TC:EXEC>
995 var charstring res:=enc_TEXT_PDU(i);
996 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
997
998 if(dec_pdu==expected_res){
999 setverdict(pass);
1000 } else {
1001 log ("enc_TEXT_PDU(i)= " , res) ;
1002 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
1003 setverdict(fail);}
1004
1005 <RESULT>
1006 Overall verdict: pass
1007 <END_TC>
1008 :exmp.
1009 :xmp tab=0.
1010
1011 <TC - Coding with leading token, using decoding matching pattern>
1012 <STATIC>
1013
1014 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1015 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1016
1017 group TEXT_group{
1018
1019 type charstring TEXT_PDU with { variant "BEGIN('Header:','(T:)|(Header:)')"};
1020
1021 } with {encode "TEXT"}
1022
1023 const TEXT_PDU i:="value"
1024 const TEXT_PDU expected_res:="value"
1025
1026 <TTCN_TC:EXEC>
1027 var charstring o := "T:value"
1028 var charstring res:=enc_TEXT_PDU(i);
1029 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
1030
1031 if(dec_pdu==expected_res){
1032 setverdict(pass);
1033 } else {setverdict(fail);}
1034 o := "Header:value"
1035 dec_pdu:=dec_TEXT_PDU(o);
1036
1037 if(dec_pdu==expected_res){
1038 setverdict(pass);
1039 } else {setverdict(fail);}
1040
1041 <RESULT>
1042 Overall verdict: pass
1043 <END_TC>
1044 :exmp.
1045 .*---------------------------------------------------------------------*
1046 :h3.Trailing token
1047 .*---------------------------------------------------------------------*
1048 :xmp tab=0.
1049
1050 <TC - Coding with trailing token>
1051 <STATIC>
1052
1053 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1054 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1055
1056 group TEXT_group{
1057
1058 type charstring TEXT_PDU with { variant "END(':close')"};
1059
1060 } with {encode "TEXT"}
1061
1062 const TEXT_PDU i:="value"
1063 const charstring o := "value:close"
1064 const TEXT_PDU expected_res:="value"
1065
1066 <TTCN_TC:EXEC>
1067 var charstring res:=enc_TEXT_PDU(i);
1068 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
1069
1070 if( res==o and dec_pdu==expected_res){
1071 setverdict(pass);
1072 } else {
1073 log ("enc_TEXT_PDU(i)= " , res) ;
1074 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
1075 setverdict(fail);}
1076
1077 <RESULT>
1078 Overall verdict: pass
1079 <END_TC>
1080 :exmp.
1081 :xmp tab=0.
1082
1083 <TC - Coding with trailing token, case insensitive decoding>
1084 <STATIC>
1085
1086 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1087 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1088
1089 group TEXT_group{
1090
1091 type charstring TEXT_PDU with { variant "END(':close',, case_insensitive)"};
1092
1093 } with {encode "TEXT"}
1094
1095 const TEXT_PDU i:="value"
1096 const charstring o := "value:CloSe"
1097 const TEXT_PDU expected_res:="value"
1098
1099 <TTCN_TC:EXEC>
1100 var charstring res:=enc_TEXT_PDU(i);
1101 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
1102
1103 if(dec_pdu==expected_res){
1104 setverdict(pass);
1105 } else {
1106 log ("enc_TEXT_PDU(i)= " , res) ;
1107 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
1108 setverdict(fail);}
1109
1110 <RESULT>
1111 Overall verdict: pass
1112 <END_TC>
1113 :exmp.
1114 :xmp tab=0.
1115
1116 <TC - Coding with leading token, using decoding matching pattern>
1117 <STATIC>
1118
1119 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1120 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1121
1122 group TEXT_group{
1123
1124 type charstring TEXT_PDU with { variant "END(':close','(:T)|(:close)')"};
1125
1126 } with {encode "TEXT"}
1127
1128 const TEXT_PDU i:="value"
1129 const TEXT_PDU expected_res:="value"
1130
1131 <TTCN_TC:EXEC>
1132 var charstring o := "value:close"
1133 var charstring res:=enc_TEXT_PDU(i);
1134 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
1135
1136 if(dec_pdu==expected_res){
1137 setverdict(pass);
1138 } else {setverdict(fail);}
1139
1140 o := "value:T"
1141 dec_pdu:=dec_TEXT_PDU(o);
1142
1143 if(dec_pdu==expected_res){
1144 setverdict(pass);
1145 } else {setverdict(fail);}
1146
1147 <RESULT>
1148 Overall verdict: pass
1149 <END_TC>
1150 :exmp.
1151 .*---------------------------------------------------------------------*
1152 :h3.Field separator token
1153 .*---------------------------------------------------------------------*
1154 :xmp tab=0.
1155
1156 <TC - Coding with separator token>
1157 <STATIC>
1158
1159 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1160 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1161
1162 group TEXT_group{
1163
1164 type record TEXT_PDU {
1165 charstring f1,
1166 charstring f2
1167 } with { variant "SEPARATOR('\n\r')"};
1168
1169 } with {encode "TEXT"}
1170
1171 const TEXT_PDU i:={f1:="value1",f2:="value2"}
1172 const charstring o := "value1\n\rvalue2"
1173 const TEXT_PDU expected_res:={f1:="value1",f2:="value2"}
1174
1175 <TTCN_TC:EXEC>
1176 var charstring res:=enc_TEXT_PDU(i);
1177 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
1178
1179 if( res==o and dec_pdu==expected_res){
1180 setverdict(pass);
1181 } else {
1182 log ("enc_TEXT_PDU(i)= " , res) ;
1183 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
1184 setverdict(fail);}
1185
1186 <RESULT>
1187 Overall verdict: pass
1188 <END_TC>
1189 :exmp.
1190 :xmp tab=0.
1191
1192 <TC - Coding with separator token, case insensitive decoding>
1193 <STATIC>
1194
1195 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1196 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1197
1198 group TEXT_group{
1199
1200 type record TEXT_PDU {
1201 charstring f1,
1202 charstring f2
1203 } with { variant "SEPARATOR(':FieldSep\n\r',,case_insensitive)"};
1204
1205 } with {encode "TEXT"}
1206
1207 const TEXT_PDU i:={f1:="value1",f2:="value2"}
1208 const charstring o := "value1:FiELDsep\n\rvalue2"
1209 const TEXT_PDU expected_res:={f1:="value1",f2:="value2"}
1210
1211 <TTCN_TC:EXEC>
1212 var charstring res:=enc_TEXT_PDU(i);
1213 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
1214
1215 if(dec_pdu==expected_res){
1216 setverdict(pass);
1217 } else {
1218 log ("enc_TEXT_PDU(i)= " , res) ;
1219 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
1220 setverdict(fail);}
1221
1222 <RESULT>
1223 Overall verdict: pass
1224 <END_TC>
1225 :exmp.
1226 :xmp tab=0.
1227
1228 <TC - Coding with separator token, using decoding matching pattern>
1229 <STATIC>
1230
1231 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1232 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1233
1234 group TEXT_group{
1235
1236 type record TEXT_PDU {
1237 charstring f1,
1238 charstring f2
1239 } with { variant "SEPARATOR(':FieldSep\n\r','(\n\r)|(:FieldSep\n\r)')"};
1240
1241 } with {encode "TEXT"}
1242
1243 const TEXT_PDU i:={f1:="value1",f2:="value2"}
1244 const TEXT_PDU expected_res:={f1:="value1",f2:="value2"}
1245
1246 <TTCN_TC:EXEC>
1247 var charstring o := "value1:FieldSep\n\rvalue2"
1248 var charstring res:=enc_TEXT_PDU(i);
1249 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
1250
1251 if(dec_pdu==expected_res){
1252 setverdict(pass);
1253 } else {setverdict(fail);}
1254
1255 o := "value1\n\rvalue2"
1256 dec_pdu:=dec_TEXT_PDU(o);
1257
1258 if(dec_pdu==expected_res){
1259 setverdict(pass);
1260 } else {setverdict(fail);}
1261
1262 <RESULT>
1263 Overall verdict: pass
1264 <END_TC>
1265 :exmp.
1266 .*---------------------------------------------------------------------*
1267 :h2.Coding of compound types
1268 .*---------------------------------------------------------------------*
1269 .*---------------------------------------------------------------------*
1270 :h3.Record
1271 .*---------------------------------------------------------------------*
1272 :xmp tab=0.
1273
1274 <TC - Record with BEGIN/END token>
1275 <STATIC>
1276
1277 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1278 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1279
1280 group TEXT_group{
1281
1282 type record TEXT_PDU {
1283 charstring f1
1284 } with { variant "BEGIN('Head:'),END(':end')"};
1285
1286 } with {encode "TEXT"}
1287
1288 const TEXT_PDU i:={f1:="value1"}
1289 const charstring o := "Head:value1:end"
1290 const TEXT_PDU expected_res:={f1:="value1"}
1291
1292 <TTCN_TC:EXEC>
1293 var charstring res:=enc_TEXT_PDU(i);
1294 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
1295
1296 if( res==o and dec_pdu==expected_res){
1297 setverdict(pass);
1298 } else {
1299 log ("enc_TEXT_PDU(i)= " , res) ;
1300 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
1301 setverdict(fail);}
1302
1303 <RESULT>
1304 Overall verdict: pass
1305 <END_TC>
1306 :exmp.
1307 :xmp tab=0.
1308
1309 <TC - Record with record fields>
1310 <STATIC>
1311
1312 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1313 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1314
1315 group TEXT_group{
1316
1317 type record rec1{
1318 charstring field1,
1319 charstring field2
1320 } with { variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
1321
1322 type record TEXT_PDU {
1323 rec1 f1,
1324 charstring f2
1325 } with { variant "BEGIN('PDU:'),END(':UDP')"};
1326
1327 } with {encode "TEXT"}
1328
1329 const TEXT_PDU i:={f1:={field1:="v1",field2:="v2"},f2:="value1"}
1330 const charstring o := "PDU:Head:v1,v2:endvalue1:UDP"
1331 const TEXT_PDU expected_res:={f1:={field1:="v1",field2:="v2"},f2:="value1"}
1332
1333 <TTCN_TC:EXEC>
1334 var charstring res:=enc_TEXT_PDU(i);
1335 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
1336
1337 if( res==o and dec_pdu==expected_res){
1338 setverdict(pass);
1339 } else {
1340 log ("enc_TEXT_PDU(i)= " , res) ;
1341 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
1342 setverdict(fail);}
1343
1344 <RESULT>
1345 Overall verdict: pass
1346 <END_TC>
1347 :exmp.
1348 :xmp tab=0.
1349
1350 <TC - Record with optional fields>
1351 <STATIC>
1352
1353 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1354 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1355
1356 group TEXT_group{
1357
1358 type record rec1{
1359 charstring field1,
1360 charstring field2
1361 } with { variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
1362
1363 type record TEXT_PDU {
1364 rec1 f1 optional,
1365 charstring f2
1366 } with { variant "BEGIN('PDU:'),END(':UDP')"};
1367
1368 } with {encode "TEXT"}
1369
1370 <TTCN_TC:EXEC>
1371 var TEXT_PDU i:={f1:={field1:="v1",field2:="v2"},f2:="value1"}
1372 var charstring o := "PDU:Head:v1,v2:endvalue1:UDP"
1373 var TEXT_PDU expected_res:={f1:={field1:="v1",field2:="v2"},f2:="value1"}
1374 var charstring res:=enc_TEXT_PDU(i);
1375 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
1376
1377 if(dec_pdu==expected_res){
1378 setverdict(pass);
1379 } else {setverdict(fail);}
1380
1381 i:={f1:=omit,f2:="value1"}
1382 o := "PDU:value1:UDP"
1383 expected_res:={f1:=omit,f2:="value1"}
1384 res:=enc_TEXT_PDU(i);
1385 dec_pdu:=dec_TEXT_PDU(o);
1386
1387 if(dec_pdu==expected_res){
1388 setverdict(pass);
1389 } else {setverdict(fail);}
1390
1391 <RESULT>
1392 Overall verdict: pass
1393 <END_TC>
1394 :exmp.
1395 .*---------------------------------------------------------------------*
1396 :h3.Set
1397 .*---------------------------------------------------------------------*
1398 :xmp tab=0.
1399
1400 <TC - Set with BEGIN/END token>
1401 <STATIC>
1402
1403 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1404 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1405
1406 group TEXT_group{
1407
1408 type set TEXT_PDU {
1409 charstring f1
1410 } with { variant "BEGIN('Head:'),END(':end')"};
1411
1412 } with {encode "TEXT"}
1413
1414 const TEXT_PDU i:={f1:="value1"}
1415 const charstring o := "Head:value1:end"
1416 const TEXT_PDU expected_res:={f1:="value1"}
1417
1418 <TTCN_TC:EXEC>
1419 var charstring res:=enc_TEXT_PDU(i);
1420 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
1421
1422 if( res==o and dec_pdu==expected_res){
1423 setverdict(pass);
1424 } else {
1425 log ("enc_TEXT_PDU(i)= " , res) ;
1426 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
1427 setverdict(fail);}
1428
1429 <RESULT>
1430 Overall verdict: pass
1431 <END_TC>
1432 :exmp.
1433 :xmp tab=0.
1434
1435 <TC - Set with record fields>
1436 <STATIC>
1437
1438 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1439 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1440
1441 group TEXT_group{
1442
1443 type set rec1{
1444 charstring field1,
1445 charstring field2
1446 } with { variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
1447
1448 type set TEXT_PDU {
1449 rec1 f1,
1450 charstring f2
1451 } with { variant "BEGIN('PDU:'),END(':UDP'),SEPARATOR(',')"};
1452
1453 } with {encode "TEXT"}
1454
1455 <TTCN_TC:EXEC>
1456 var TEXT_PDU i:={f1:={field1:="v1",field2:="v2"},f2:="value1"}
1457 var charstring o := "PDU:Head:v1,v2:end,value1:UDP"
1458 var charstring o2 := "PDU:value1,Head:v1,v2:end:UDP"
1459 var TEXT_PDU expected_res:={f1:={field1:="v1",field2:="v2"},f2:="value1"}
1460 var charstring res:=enc_TEXT_PDU(i);
1461 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
1462 var TEXT_PDU dec_pdu2:=dec_TEXT_PDU(o2);
1463
1464 if(dec_pdu==expected_res and dec_pdu2==expected_res){
1465 setverdict(pass);
1466 } else {setverdict(fail);}
1467
1468 <RESULT>
1469 Overall verdict: pass
1470 <END_TC>
1471 :exmp.
1472 :xmp tab=0.
1473
1474 <TC - Set with optional fields>
1475 <STATIC>
1476
1477 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1478 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1479
1480 group TEXT_group{
1481
1482 type record rec1{
1483 charstring field1,
1484 charstring field2
1485 } with { variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
1486
1487 type set TEXT_PDU {
1488 rec1 f1 optional,
1489 charstring f2
1490 } with { variant "BEGIN('PDU:'),END(':UDP')"};
1491
1492 } with {encode "TEXT"}
1493
1494 <TTCN_TC:EXEC>
1495 var TEXT_PDU i:={f1:={field1:="v1",field2:="v2"},f2:="value1"}
1496 var charstring o := "PDU:Head:v1,v2:endvalue1:UDP"
1497 var TEXT_PDU expected_res:={f1:={field1:="v1",field2:="v2"},f2:="value1"}
1498 var charstring res:=enc_TEXT_PDU(i);
1499 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
1500
1501 if(dec_pdu==expected_res){
1502 setverdict(pass);
1503 } else {setverdict(fail);}
1504
1505 i:={f1:=omit,f2:="value1"}
1506 o := "PDU:value1:UDP"
1507 expected_res:={f1:=omit,f2:="value1"}
1508 res:=enc_TEXT_PDU(i);
1509 dec_pdu:=dec_TEXT_PDU(o);
1510
1511 if(dec_pdu==expected_res){
1512 setverdict(pass);
1513 } else {setverdict(fail);}
1514
1515 <RESULT>
1516 Overall verdict: pass
1517 <END_TC>
1518 :exmp.
1519
1520 :xmp tab=0.
1521
1522 <TC - Set with set of type fields>
1523 <STATIC>
1524
1525 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1526 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1527
1528 group TEXT_group{
1529
1530 type set of charstring sof with {variant "SEPARATOR(',')"}
1531
1532 type set TEXT_PDU {
1533 charstring f1,
1534 charstring f2 optional,
1535 sof f3,
1536 sof f4 optional,
1537 sof f5,
1538 charstring f6
1539 } with { variant "BEGIN('Head:'),END(':end')";
1540 variant (f1) "BEGIN('f1:')";
1541 variant (f2) "BEGIN('f2:')";
1542 variant (f3) "BEGIN('f3:')";
1543 variant (f4) "BEGIN('f4:'),TEXT_CODING(,repeatable=true)";
1544 variant (f5) "BEGIN('f5:'),TEXT_CODING(,repeatable=true)";
1545 variant (f6) "BEGIN('f6:')";
1546 variant "SEPARATOR(';')" };
1547
1548 } with {encode "TEXT"}
1549
1550 const TEXT_PDU i:={f1:="value1",
1551 f2:=omit,
1552 f3:={"sof1","sof1a","sof1b"},
1553 f4:={"sof2","sof2a","sof2b"},
1554 f5:={"sof3","sof3a","sof3b"},
1555 f6:="value6" }
1556
1557 <TTCN_TC:EXEC>
1558 var charstring o := "Head:f1:value1;f3:sof1,sof1a,sof1b;f4:sof2,sof2a,sof2b;f5:sof3,sof3a,sof3b;f6:value6:end"
1559 var TEXT_PDU expected_res:={f1:="value1",
1560 f2:=omit,
1561 f3:={"sof1","sof1a","sof1b"},
1562 f4:={"sof2","sof2a","sof2b"},
1563 f5:={"sof3","sof3a","sof3b"},
1564 f6:="value6" }
1565 var charstring res:=enc_TEXT_PDU(i);
1566 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
1567
1568 if(dec_pdu==expected_res){
1569 setverdict(pass);
1570 } else {setverdict(fail);}
1571
1572 o := "Head:f5:sof3a,sof3b;f3:sof1,sof1a,sof1b;f4:sof2;f1:value1;f4:sof2a,sof2b;f5:sof3;f6:value6:end"
1573 expected_res:={f1:="value1",
1574 f2:=omit,
1575 f3:={"sof1","sof1a","sof1b"},
1576 f4:={"sof2","sof2a","sof2b"},
1577 f5:={"sof3","sof3a","sof3b"},
1578 f6:="value6" }
1579 dec_pdu:=dec_TEXT_PDU(o);
1580
1581 if(dec_pdu==expected_res){
1582 setverdict(pass);
1583 } else {setverdict(fail);}
1584 o := "Head:f5:sof3a,sof3b;f3:sof1,sof1a,sof1b;f1:value1;f5:sof3;f6:value6:end"
1585 expected_res:={f1:="value1",
1586 f2:=omit,
1587 f3:={"sof1","sof1a","sof1b"},
1588 f4:=omit,
1589 f5:={"sof3","sof3a","sof3b"},
1590 f6:="value6" }
1591 dec_pdu:=dec_TEXT_PDU(o);
1592
1593 if(dec_pdu==expected_res){
1594 setverdict(pass);
1595 } else {setverdict(fail);}
1596
1597 <RESULT>
1598 Overall verdict: pass
1599 <END_TC>
1600 :exmp.
1601 .*---------------------------------------------------------------------*
1602 :h3.Record/Set of
1603 .*---------------------------------------------------------------------*
1604 :xmp tab=0.
1605
1606 <TC - Record of with BEGIN/END token>
1607 <STATIC>
1608
1609 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1610 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1611
1612 group TEXT_group{
1613
1614 type record of charstring TEXT_PDU
1615 with { variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
1616
1617 } with {encode "TEXT"}
1618
1619 const TEXT_PDU i:={"value1","value2","value3"}
1620 const charstring o := "Head:value1,value2,value3:end"
1621 const TEXT_PDU expected_res:={"value1","value2","value3"}
1622
1623 <TTCN_TC:EXEC>
1624 var charstring res:=enc_TEXT_PDU(i);
1625 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
1626
1627 if( res==o and dec_pdu==expected_res){
1628 setverdict(pass);
1629 } else {
1630 log ("enc_TEXT_PDU(i)= " , res) ;
1631 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
1632 setverdict(fail);}
1633
1634 <RESULT>
1635 Overall verdict: pass
1636 <END_TC>
1637 :exmp.
1638 :xmp tab=0.
1639
1640 <TC - Record of with record fields>
1641 <STATIC>
1642
1643 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1644 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1645
1646 group TEXT_group{
1647
1648 type record rec1{
1649 charstring field1,
1650 charstring field2
1651 } with { variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
1652
1653 type record of rec1 TEXT_PDU with { variant "BEGIN('PDU:'),END(':UDP')"};
1654
1655 } with {encode "TEXT"}
1656
1657 const TEXT_PDU i:={{field1:="v1",field2:="v2"},{field1:="v3",field2:="v4"}}
1658 const charstring o := "PDU:Head:v1,v2:endHead:v3,v4:end:UDP"
1659 const TEXT_PDU expected_res:={{field1:="v1",field2:="v2"},{field1:="v3",field2:="v4"}}
1660
1661 <TTCN_TC:EXEC>
1662 var charstring res:=enc_TEXT_PDU(i);
1663 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(res);
1664
1665 if( res==o and dec_pdu==expected_res){
1666 setverdict(pass);
1667 } else {
1668 log ("enc_TEXT_PDU(i)= " , res) ;
1669 log ("dec_TEXT_PDU(res)= " , dec_pdu) ;
1670 setverdict(fail);}
1671
1672 <RESULT>
1673 Overall verdict: pass
1674 <END_TC>
1675 :exmp.
1676 :xmp tab=0.
1677
1678 <TC - Empty record of>
1679 <STATIC>
1680
1681 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1682 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1683
1684 group TEXT_group{
1685
1686 type record rec1{
1687 charstring field1,
1688 charstring field2
1689 } with { variant "BEGIN('Head:'),END(':end'),SEPARATOR(',')"};
1690
1691 type record of rec1 TEXT_PDU with { variant "BEGIN('PDU:'),END(':UDP')"};
1692
1693 } with {encode "TEXT"}
1694
1695 <TTCN_TC:EXEC>
1696 var TEXT_PDU i:={}
1697 var charstring o := "PDU::UDP"
1698 var TEXT_PDU expected_res:={}
1699 var charstring res:=enc_TEXT_PDU(i);
1700 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
1701
1702 if(dec_pdu==expected_res){
1703 setverdict(pass);
1704 } else {setverdict(fail);}
1705
1706 <RESULT>
1707 Overall verdict: pass
1708 <END_TC>
1709 :exmp.
1710 .*---------------------------------------------------------------------*
1711 :h3.Union
1712 .*---------------------------------------------------------------------*
1713 :xmp tab=0.
1714
1715 <TC - Union with BEGIN/END token>
1716 <STATIC>
1717
1718 external function enc_TEXT_PDU(in TEXT_PDU pdu) return charstring with { extension "prototype(convert) encode(TEXT)" }
1719 external function dec_TEXT_PDU(in charstring oct) return TEXT_PDU with { extension "prototype(convert) decode(TEXT)" }
1720
1721 group TEXT_group{
1722
1723 type union TEXT_PDU {
1724 charstring f1,
1725 charstring f2
1726 } with { variant "BEGIN('Head:'),END(':end')";
1727 variant (f1) "BEGIN('f1:'),END(':1f')"
1728 variant (f2) "BEGIN('f2:'),END(':2f')" };
1729 } with {encode "TEXT"}
1730
1731 const TEXT_PDU i:={f1:="value1"}
1732
1733 <TTCN_TC:EXEC>
1734 var charstring o := "Head:f1:value1:1f:end"
1735 var TEXT_PDU expected_res:={f1:="value1"}
1736 var charstring res:=enc_TEXT_PDU(i);
1737 var TEXT_PDU dec_pdu:=dec_TEXT_PDU(o);
1738
1739 if(dec_pdu==expected_res){
1740 setverdict(pass);
1741 } else {setverdict(fail);}
1742
1743 o := "Head:f2:value2:2f:end"
1744 expected_res:={f2:="value2"}
1745 dec_pdu:=dec_TEXT_PDU(o);
1746 //log(o);
1747 //log(dec_pdu);
1748 if(dec_pdu==expected_res){
1749 setverdict(pass);
1750 } else {setverdict(fail);}
1751
1752 <RESULT>
1753 Overall verdict: pass
1754 <END_TC>
1755 :exmp.
1756 :xmp tab=0.
1757
1758
1759 .*---------------------------------------------------------------------*
1760 :h3.Fast
1761 .*---------------------------------------------------------------------*
1762 :xmp tab=0.
1763
1764 <TC - implicit message encoding: prototype fast>
1765 <STATIC>
1766
1767 external function fast_enc_TEXT_PDU(in TEXT_PDU pdu, out charstring cs) with { extension "prototype(fast) encode(TEXT)" }
1768 external function fast_dec_TEXT_PDU(in charstring cs, out TEXT_PDU pdu) with { extension "prototype(fast) decode(TEXT)" }
1769
1770 group TEXT_group{
1771
1772 type union TEXT_PDU {
1773 charstring f1,
1774 charstring f2
1775 } with { variant "BEGIN('Head:'),END(':end')";
1776 variant (f1) "BEGIN('f1:'),END(':1f')"
1777 variant (f2) "BEGIN('f2:'),END(':2f')" };
1778 } with {encode "TEXT"}
1779
1780 const TEXT_PDU i:={f1:="value1"}
1781
1782 <TTCN_TC:EXEC>
1783 var charstring o := "Head:f1:value1:1f:end"
1784 var TEXT_PDU expected_res:={f1:="value1"}
1785 var charstring res;
1786 fast_enc_TEXT_PDU(i, res);
1787 var TEXT_PDU dec_pdu;
1788 fast_dec_TEXT_PDU(o, dec_pdu);
1789
1790 if(dec_pdu==expected_res){
1791 setverdict(pass);
1792 } else {setverdict(fail);}
1793
1794 o := "Head:f2:value2:2f:end"
1795 expected_res:={f2:="value2"}
1796 fast_dec_TEXT_PDU(o, dec_pdu);
1797
1798 if(dec_pdu==expected_res){
1799 setverdict(pass);
1800 } else {setverdict(fail);}
1801
1802 <RESULT>
1803 Overall verdict: pass
1804 <END_TC>
1805 :exmp.
1806 :xmp tab=0.
1807
1808 .*---------------------------------------------------------------------*
1809 :h3.Backtrack
1810 .*---------------------------------------------------------------------*
1811 :xmp tab=0.
1812
1813 <TC - implicit message encoding: prototype backtrack>
1814 <STATIC>
1815
1816 external function fast_enc_TEXT_PDU(in TEXT_PDU pdu, out charstring cs)
1817 with { extension "prototype(fast) encode(TEXT)" }
1818 external function backtrack_dec_TEXT_PDU(in charstring cs, out TEXT_PDU pdu) return integer
1819 with { extension "prototype(backtrack) decode(TEXT) errorbehavior(ALL:WARNING)" }
1820
1821 type integer TEXT_PDU with { variant "TEXT_CODING()" }
1822
1823 <TTCN_TC:EXEC>
1824
1825 var TEXT_PDU bs := 42;
1826 var TEXT_PDU decoded_bs;
1827 var charstring enc_bs;
1828 var integer ret_val;
1829 var charstring invalid_enc_bs := "bruhaha";
1830
1831 fast_enc_TEXT_PDU(bs, enc_bs);
1832 ret_val := backtrack_dec_TEXT_PDU(enc_bs, decoded_bs);
1833 if (ret_val==0) { setverdict(pass); } else { setverdict(fail); }
1834 if (decoded_bs==bs) { setverdict(pass); } else { setverdict(fail); }
1835 ret_val := backtrack_dec_TEXT_PDU(invalid_enc_bs, decoded_bs);
1836 if (ret_val==1) { setverdict(pass); } else { setverdict(fail); }
1837
1838 <RESULT>
1839 Overall verdict: pass
1840 <END_TC>
1841
1842 :exmp.
1843
1844 .*---------------------------------------------------------------------*
1845 :h3.Sliding
1846 .*---------------------------------------------------------------------*
1847 :xmp tab=0.
1848
1849
1850 <TC - implicit message encoding: prototype sliding>
1851 <STATIC>
1852
1853 external function sliding_dec_TEXT_PDU(inout charstring cs, out TEXT_PDU pdu) return integer
1854 with { extension "prototype(sliding) decode(TEXT) errorbehavior(ALL:WARNING)" }
1855
1856 type integer TEXT_PDU with { variant "TEXT_CODING(length=4)" }
1857
1858 <TTCN_TC:EXEC>
1859
1860 var TEXT_PDU out_pdu;
1861 var charstring enc_pdu1 := " 42 21";
1862 var integer ret_val;
1863
1864 ret_val := sliding_dec_TEXT_PDU(enc_pdu1, out_pdu);
1865 if (ret_val==0 and out_pdu==42) { setverdict(pass); } else { setverdict(fail); }
1866 ret_val := sliding_dec_TEXT_PDU(enc_pdu1, out_pdu);
1867 if (ret_val==0 and out_pdu==21) { setverdict(pass); } else { setverdict(fail); }
1868 ret_val := sliding_dec_TEXT_PDU(enc_pdu1, out_pdu);
1869
1870 <RESULT>
1871 Overall verdict: pass
1872 <END_TC>
1873
1874 :exmp.
1875
1876 .*---------------------------------------------------------------------*
1877 :h2. Encoding/decoding of big integers
1878 .*---------------------------------------------------------------------*
1879 .*---------------------------------------------------------------------*
1880 :h3.Big integer fields
1881 .*---------------------------------------------------------------------*
1882 :xmp tab=0.
1883
1884
1885 <TC - big integers: big integer fields>
1886 <STATIC>
1887
1888 external function enc_text(in rec_text r) return charstring
1889 with { extension "encode(TEXT) prototype(convert) errorbehavior(ALL:WARNING)" }
1890 external function dec_text(in charstring r) return rec_text
1891 with { extension "decode(TEXT) prototype(convert) errorbehavior(ALL:WARNING)" }
1892
1893 type integer myint1 with {
1894 variant "BEGIN('<myint>')"
1895 variant "END('</myint>')"
1896 encode "TEXT" }
1897
1898 type integer myint2 with {
1899 variant "BEGIN('<myint_dummy>')"
1900 variant "END('</myint_dummy>')"
1901 variant "TEXT_CODING(length=128;leading0=true)"
1902 encode "TEXT" }
1903
1904 type integer myint3 with {
1905 variant "BEGIN('<myint_super>')"
1906 variant "END('</myint_super>')"
1907 encode "TEXT" }
1908
1909 type integer myint4 with {
1910 variant "TEXT_CODING(length=256)"
1911 variant "BEGIN('<myint_pad>')"
1912 variant "END('</myint_pad>')"
1913 encode "TEXT" }
1914
1915 type record rec_text {
1916 myint1 int1,
1917 myint1 int2,
1918 myint2 int3 optional,
1919 myint3 int4 optional,
1920 myint4 int5 optional
1921 } with {
1922 variant "BEGIN('<rec_text>')"
1923 // `variant "SEPARATOR(',')"' is not necessary if the fields can be found
1924 // unambigously.
1925 variant "END('</rec_text>')"
1926 encode "TEXT" }
1927
1928 <TTCN_TC:EXEC>
1929 const integer a := 214748364799
1930 const integer b := 214748364788
1931 const integer c := 0
1932 // Implicit `omit' would be great.
1933 var rec_text myrec1 := {int1 := 214748364799, int2 := 214748364788, int3 := omit, int4 := omit, int5 := omit}
1934 var rec_text myrec2 := {214748364799, 214748364788, omit, omit, omit}
1935 var rec_text myrec3 := {214748364799, 0, omit, omit, omit}
1936 var rec_text myrec4 := {int1 := 214748364799, int2 := 0, int3 := omit, int4 := omit, int5 := omit}
1937 var rec_text myrec5 := {int1 := 0, int2 := 214748364788, int3 := omit, int4 := omit, int5 := omit}
1938 var rec_text myrec6 := {0, 214748364788, omit, omit, omit}
1939 var rec_text myrec7 := {0, 0, omit, omit, omit}
1940 var rec_text myrec8 := {int1 := 0, int2 := 0, int3 := omit, int4 := omit, int5 := omit}
1941 var rec_text myrec9 := {int1 := a, int2 := b, int3 := omit, int4 := omit, int5 := omit}
1942 var rec_text myrec10 := {a, b, omit, omit, omit}
1943 // The original `sprintf' encoder encodes negative values `-' <padding>
1944 // `0123456'. We should work similarly.
1945 var rec_text myrec11 := {
1946 int1 := -11111111111111111111111111111,
1947 int2 := 22222222222222222222222222222,
1948 int3 := -33333333333333333333333333333,
1949 int4 := 2147483648,
1950 int5 := -2147483648 }
1951 var rec_text myrec12 := {int1 := 0, int2 := 0, int3 := 0, int4 := -1111111111111111111111111111111, int5 := -1234567891011121314151617181920}
1952 var rec_text myrec13 := {-0, -0, -0, -0, -0}
1953 var rec_text myrec14 := {-0, -1, 1234567891011121314151617181920, -1111111111111111111111111111111, -0}
1954 var rec_text myrec15 := {int1 := 1111111111111111111111111111111, int2 := -1234567891011121314151617181920, int3 := 0, int4 := -0, int5 := -111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111}
1955 var charstring ret_val
1956 ret_val := enc_text(myrec1)
1957 if (dec_text(ret_val) == myrec1) { setverdict(pass) } else { setverdict(fail) }
1958 if (dec_text(ret_val) == {int1 := 214748364799, int2 := 214748364788, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1959 ret_val := enc_text(myrec2)
1960 if (dec_text(ret_val) == myrec2) { setverdict(pass) } else { setverdict(fail) }
1961 if (dec_text(ret_val) == {214748364799, 214748364788, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1962 ret_val := enc_text(myrec3)
1963 if (dec_text(ret_val) == myrec3) { setverdict(pass) } else { setverdict(fail) }
1964 if (dec_text(ret_val) == {214748364799, 0, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1965 ret_val := enc_text(myrec4)
1966 if (dec_text(ret_val) == myrec4) { setverdict(pass) } else { setverdict(fail) }
1967 if (dec_text(ret_val) == {int1 := 214748364799, int2 := 0, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1968 ret_val := enc_text(myrec5)
1969 if (dec_text(ret_val) == myrec5) { setverdict(pass) } else { setverdict(fail) }
1970 if (dec_text(ret_val) == {int1 := 0, int2 := 214748364788, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1971 ret_val := enc_text(myrec6)
1972 if (dec_text(ret_val) == myrec6) { setverdict(pass) } else { setverdict(fail) }
1973 if (dec_text(ret_val) == {0, 214748364788, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1974 ret_val := enc_text(myrec7)
1975 if (dec_text(ret_val) == myrec7) { setverdict(pass) } else { setverdict(fail) }
1976 if (dec_text(ret_val) == {0, 0, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1977 ret_val := enc_text(myrec8)
1978 if (dec_text(ret_val) == myrec8) { setverdict(pass) } else { setverdict(fail) }
1979 if (dec_text(ret_val) == {int1 := 0, int2 := 0, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1980 ret_val := enc_text(myrec9)
1981 if (dec_text(ret_val) == myrec9) { setverdict(pass) } else { setverdict(fail) }
1982 if (dec_text(ret_val) == {int1 := a, int2 := b, int3 := omit, int4 := omit, int5 := omit}) { setverdict(pass) } else { setverdict(fail) }
1983 ret_val := enc_text(myrec10)
1984 if (dec_text(ret_val) == myrec10) { setverdict(pass) } else { setverdict(fail) }
1985 if (dec_text(ret_val) == {a, b, omit, omit, omit}) { setverdict(pass) } else { setverdict(fail) }
1986 ret_val := enc_text(myrec11)
1987 if (dec_text(ret_val) == myrec11) { setverdict(pass) } else { setverdict(fail) }
1988 if (dec_text(ret_val) == {int1 := -11111111111111111111111111111, int2 := 22222222222222222222222222222, int3 := -33333333333333333333333333333, int4 := 2147483648, int5 := -2147483648}) { setverdict(pass) } else { setverdict(fail) }
1989 ret_val := enc_text(myrec12)
1990 if (dec_text(ret_val) == myrec12) { setverdict(pass) } else { setverdict(fail) }
1991 if (dec_text(ret_val) == {int1 := 0, int2 := 0, int3 := 0, int4 := -1111111111111111111111111111111, int5 := -1234567891011121314151617181920}) { setverdict(pass) } else { setverdict(fail) }
1992 ret_val := enc_text(myrec13)
1993 if (dec_text(ret_val) == myrec13) { setverdict(pass) } else { setverdict(fail) }
1994 if (dec_text(ret_val) == {-0, -0, -0, -0, -0}) { setverdict(pass) } else { setverdict(fail) }
1995 ret_val := enc_text(myrec14)
1996 if (dec_text(ret_val) == myrec14) { setverdict(pass) } else { setverdict(fail) }
1997 if (dec_text(ret_val) == {-0, -1, 1234567891011121314151617181920, -1111111111111111111111111111111, -0}) { setverdict(pass) } else { setverdict(fail) }
1998 ret_val := enc_text(myrec15)
1999 if (dec_text(ret_val) == myrec15) { setverdict(pass) } else { setverdict(fail) }
2000 if (dec_text(ret_val) == {int1 := 1111111111111111111111111111111, int2 := -1234567891011121314151617181920, int3 := 0, int4 := -0, int5 := -111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111}) { setverdict(pass) } else { setverdict(fail) }
2001
2002 <RESULT>
2003 Overall verdict: pass
2004 <END_TC>
2005
2006 :exmp.
2007
2008 .*---------------------------------------------------------------------*
2009 :h3.Sliding encoding/decoding of big integers
2010 .*---------------------------------------------------------------------*
2011 :xmp tab=0.
2012
2013
2014 <TC - big integers: sliding encoding/decoding of big integers>
2015 <STATIC>
2016
2017 external function dec_text_sliding(inout charstring r, out myint5 s) return integer
2018 with { extension "prototype(sliding) decode(TEXT) errorbehavior(ALL:WARNING)" }
2019
2020 type integer myint5 with { variant "TEXT_CODING(length=25)" }
2021
2022 <TTCN_TC:EXEC>
2023 var myint5 decoded
2024 var charstring encoded := " 12345678910111213141516 -11111111111111111111"
2025 var integer ret_val
2026 var template integer intt := 12345678910111213141516
2027 ret_val := dec_text_sliding(encoded, decoded)
2028 if (ret_val == 0 and decoded == 12345678910111213141516) {setverdict(pass)}
2029 else {setverdict(fail)}
2030 ret_val := dec_text_sliding(encoded, decoded)
2031 if (ret_val == 0 and decoded == -11111111111111111111) {setverdict(pass)}
2032 else {setverdict(fail)}
2033 ret_val := dec_text_sliding(encoded, decoded)
2034 if (match(12345678910111213141516, intt)) {setverdict(pass)}
2035 else {setverdict(fail)}
2036
2037 <RESULT>
2038 Overall verdict: pass
2039 <END_TC>
2040
2041 :exmp.
2042 .*---------------------------------------------------------------------*
2043 :h1.REFERENCES
2044 .*---------------------------------------------------------------------*
2045 :nl. Requirement specification(s):
2046 :nl.-------------------------------
2047 :list.
2048 :li. 3/ETH/RUS-2003:0087 Uen - Requirement Specification for TITAN's TTCN-3 Semantic Analyser
2049 :elist.
2050
2051 :etext.
Titan Core - Deliverables
This page took 0.074752 seconds and 6 git commands to generate.