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 .******************************************************************************/
11 :docname.Test Description
12 :docno.8/152 91-CRL 113 200/3 Uen
16 :prep.ETH/XZR Krisztian Pandi
17 :appr.ETH/XZ (Gyula Koos)
20 :title.Test Description - BER coder
22 .*---------------------------------------------------------------------*
23 :h1.PREREQUISITES AND PREPARATIONS
24 .*---------------------------------------------------------------------*
25 .*---------------------------------------------------------------------*
26 :h2.Scope of the Test Object
27 .*---------------------------------------------------------------------*
30 This file is obsolate, don't modify, improve it anymore!
32 This TD contains test cases related to TTCN3 Executor's BER coder function.
33 DON'T YOU DARE TO WRITE AN INSPECTION RECORD ABOUT THIS FILE.
37 :p.:us.Revision Information:eus.
42 REV DATE PREPARED CHANGE
43 === ========== ======== ======
44 A 2003-10-31 ETHEKR New document
45 B 2007-03-06 EDMDELI Implicit message encoding
46 C 2007-03-21 EJNOSZA Bugfix in a testcase for implicit msg. enc.
47 D 2008-10-01 EFERKOV Big integers
48 E 2010-01-18 EKRISZA Updated for TITAN R8C
49 F 2011-06-18 EKRISZA Added tests for errors
50 A 2011-12-12 EKRISZA Updated for release
51 A 2012-06-27 EFERKOV Updated for release
52 A 2013-01-17 EKRIPND Updated for release
55 .*---------------------------------------------------------------------*
57 .*---------------------------------------------------------------------*
58 :p.:us.Software Tools:eus.
65 .*---------------------------------------------------------------------*
66 :h1.REQUIREMENT-BASED TESTS
67 .*---------------------------------------------------------------------*
68 .*---------------------------------------------------------------------*
69 :h2.Testing FIELDLENGTH Attribute
70 .*---------------------------------------------------------------------*
71 .*---------------------------------------------------------------------*
72 :h3. DER + CER encoding of BOOLEAN TRUE
73 .*---------------------------------------------------------------------*
76 <TC - DER + CER encoding of BOOLEAN TRUE >
91 import from TempA all;
92 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
93 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
95 const BERPDU b := true
99 if ((enc_DER_PDU(b) == '0101FF'O)and(enc_CER_PDU(b) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);}
103 Overall verdict: pass
109 .*---------------------------------------------------------------------*
110 :h3. DER + CER encoding of BOOLEAN FALSE
111 .*---------------------------------------------------------------------*
114 <TC - DER + CER encoding of BOOLEAN FALSE >
127 import from TempA all;
128 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
129 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
131 const BERPDU b := false
135 if ((enc_DER_PDU(b) == '010100'O)and(enc_CER_PDU(b) == '010100'O)) {setverdict(pass);} else {setverdict(fail);}
139 Overall verdict: pass
145 .*---------------------------------------------------------------------*
146 :h3. DER + CER encoding of BOOLEAN with Context Specific TAG, EXPLICIT
147 .*---------------------------------------------------------------------*
150 <TC - DER + CER encoding of BOOLEAN with Context Specific TAG, EXPLICIT>
158 BERPDU ::= [0] EXPLICIT BOOLEAN
163 import from TempA all;
164 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
165 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
167 const BERPDU b := true
171 if ((enc_DER_PDU(b) == 'A0030101FF'O)and(enc_CER_PDU(b) == 'A0800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
175 Overall verdict: pass
181 .*---------------------------------------------------------------------*
182 :h3. DER + CER encoding of BOOLEAN with PRIVATE TAG, EXPLICIT
183 .*---------------------------------------------------------------------*
186 <TC - DER + CER encoding of BOOLEAN with PRIVATE TAG, EXPLICIT>
194 BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN
199 import from TempA all;
200 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
201 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
203 const BERPDU b := true
207 if ((enc_DER_PDU(b) == 'E1030101FF'O)and(enc_CER_PDU(b) == 'E1800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
211 Overall verdict: pass
217 .*---------------------------------------------------------------------*
218 :h3. DER + CER encoding of BOOLEAN with APPLICATION TAG, EXPLICIT
219 .*---------------------------------------------------------------------*
222 <TC - DER + CER encoding of BOOLEAN with APPLICATION TAG, EXPLICIT>
230 BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN
235 import from TempA all;
236 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
237 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
239 const BERPDU b := true
243 if ((enc_DER_PDU(b) == '62030101FF'O)and(enc_CER_PDU(b) == '62800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
247 Overall verdict: pass
253 .*---------------------------------------------------------------------*
254 :h3. DER + CER encoding of BOOLEAN with Context Specific TAG, IMPLICIT
255 .*---------------------------------------------------------------------*
258 <TC - DER + CER encoding of BOOLEAN with Context Specific TAG, IMPLICIT>
266 BERPDU ::= [0] IMPLICIT BOOLEAN
271 import from TempA all;
272 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
273 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
275 const BERPDU b := false
279 if ((enc_DER_PDU(b) == '800100'O)and(enc_CER_PDU(b) == '800100'O)) {setverdict(pass);} else {setverdict(fail);}
283 Overall verdict: pass
289 .*---------------------------------------------------------------------*
290 :h3. DER + CER encoding of BOOLEAN with PRIVATE TAG, IMPLICIT
291 .*---------------------------------------------------------------------*
294 <TC - DER + CER encoding of BOOLEAN with PRIVATE TAG, IMPLICIT>
302 BERPDU ::= [PRIVATE 1] IMPLICIT BOOLEAN
307 import from TempA all;
308 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
309 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
311 const BERPDU b := false
315 if ((enc_DER_PDU(b) == 'C10100'O)and(enc_CER_PDU(b) == 'C10100'O)) {setverdict(pass);} else {setverdict(fail);}
319 Overall verdict: pass
325 .*---------------------------------------------------------------------*
326 :h3. DER + CER encoding of BOOLEAN with APPLICATION TAG, IMPLICIT
327 .*---------------------------------------------------------------------*
330 <TC - DER + CER encoding of BOOLEAN with APPLICATION TAG, IMPLICIT>
338 BERPDU ::= [APPLICATION 2] IMPLICIT BOOLEAN
343 import from TempA all;
344 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
345 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
347 const BERPDU b := true
351 if ((enc_DER_PDU(b) == '4201FF'O)and(enc_CER_PDU(b) == '4201FF'O)) {setverdict(pass);} else {setverdict(fail);}
355 Overall verdict: pass
361 .*---------------------------------------------------------------------*
362 :h3. DECODING BOOLEAN, CER+DER
363 .*---------------------------------------------------------------------*
366 <TC - DECODING BOOLEAN, CER+DER>
376 myBooleanValue BERPDU ::= TRUE
382 import from TempA all;
384 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
389 if (dec_BER_PDU('0101FF'O) == myBooleanValue)
392 {setverdict(pass);} else {setverdict(fail);}
397 Overall verdict: pass
403 .*---------------------------------------------------------------------*
404 :h3. DECODING BOOLEAN, CER+DER
405 .*---------------------------------------------------------------------*
408 <TC - DECODING BOOLEAN, CER+DER>
418 myBooleanValue BERPDU ::= FALSE
424 import from TempA all;
426 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
431 if (dec_BER_PDU('010100'O) == myBooleanValue)
434 {setverdict(pass);} else {setverdict(fail);}
439 Overall verdict: pass
445 .*---------------------------------------------------------------------*
446 :h3. DECODING BOOLEAN, (LENGTH OF LENGTH = 1)
447 .*---------------------------------------------------------------------*
450 <TC - DECODING BOOLEAN, (LENGTH OF LENGTH = 1)>
460 myBooleanValue BERPDU ::= TRUE
466 import from TempA all;
468 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
473 if (dec_BER_PDU('05810101'O) == myBooleanValue)
476 {setverdict(pass);} else {setverdict(fail);}
481 Overall verdict: pass
487 .*---------------------------------------------------------------------*
488 :h3. DECODING BOOELAN, (LENGTH OF LENGTH = 2)
489 .*---------------------------------------------------------------------*
492 <TC - DECODING BOOELAN, (LENGTH OF LENGTH = 2)>
502 myBooleanValue BERPDU ::= FALSE
508 import from TempA all;
510 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
515 if (dec_BER_PDU('0582000100'O) == myBooleanValue)
518 {setverdict(pass);} else {setverdict(fail);}
523 Overall verdict: pass
529 .*---------------------------------------------------------------------*
530 :h3. DECODING [0] EXPLICIT BOOLEAN , DER, Short form - short form
531 .*---------------------------------------------------------------------*
534 <TC - DECODING [0] EXPLICIT BOOLEAN , DER, Short form - short form>
542 BERPDU ::= [0] EXPLICIT BOOLEAN
544 myBooleanValue BERPDU ::= TRUE
550 import from TempA all;
552 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
557 if (dec_BER_PDU('A0030101FF'O) == myBooleanValue)
560 {setverdict(pass);} else {setverdict(fail);}
565 Overall verdict: pass
571 .*---------------------------------------------------------------------*
572 :h3. DECODING [0] EXPLICIT BOOLEAN, CER
573 .*---------------------------------------------------------------------*
576 <TC - DECODING [0] EXPLICIT BOOLEAN, CER>
584 BERPDU ::= [0] EXPLICIT BOOLEAN
586 myBooleanValue BERPDU ::= TRUE
592 import from TempA all;
594 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
599 if (dec_BER_PDU('A0800101FF0000'O) == myBooleanValue)
602 {setverdict(pass);} else {setverdict(fail);}
607 Overall verdict: pass
613 .*---------------------------------------------------------------------*
614 :h3. DECODING [0] EXPLICIT BOOLEAN, Long form - short form
615 .*---------------------------------------------------------------------*
618 <TC - DECODING [0] EXPLICIT BOOLEAN, Long form - short form>
626 BERPDU ::= [0] EXPLICIT BOOLEAN
628 myBooleanValue BERPDU ::= TRUE
634 import from TempA all;
636 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
641 if (dec_BER_PDU('A081030101FF'O) == myBooleanValue)
644 {setverdict(pass);} else {setverdict(fail);}
649 Overall verdict: pass
655 .*---------------------------------------------------------------------*
656 :h3. DECODING [0] EXPLICIT BOOLEAN, Long form Long form
657 .*---------------------------------------------------------------------*
660 <TC - DECODING [0] EXPLICIT BOOLEAN, Long form Long form>
668 BERPDU ::= [0] EXPLICIT BOOLEAN
670 myBooleanValue BERPDU ::= TRUE
676 import from TempA all;
678 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
683 if (dec_BER_PDU('A0810401810199'O) == myBooleanValue)
686 {setverdict(pass);} else {setverdict(fail);}
691 Overall verdict: pass
697 .*---------------------------------------------------------------------*
698 :h3. DECODING [PRIVATE 1] EXPLICIT BOOLEAN , DER, Short form - short form
699 .*---------------------------------------------------------------------*
702 <TC - DECODING [PRIVATE 1] EXPLICIT BOOLEAN , DER, Short form - short form>
710 BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN
712 myBooleanValue BERPDU ::= TRUE
718 import from TempA all;
720 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
725 if (dec_BER_PDU('E1030101FF'O) == myBooleanValue)
728 {setverdict(pass);} else {setverdict(fail);}
733 Overall verdict: pass
739 .*---------------------------------------------------------------------*
740 :h3. DECODING [PRIVATE 1] EXPLICIT BOOLEAN, CER
741 .*---------------------------------------------------------------------*
744 <TC - DECODING [PRIVATE 1] EXPLICIT BOOLEAN, CER>
752 BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN
754 myBooleanValue BERPDU ::= TRUE
760 import from TempA all;
762 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
767 if (dec_BER_PDU('E1800101FF0000'O) == myBooleanValue)
770 {setverdict(pass);} else {setverdict(fail);}
775 Overall verdict: pass
781 .*---------------------------------------------------------------------*
782 :h3. DECODING [PRIVATE 1] EXPLICIT BOOLEAN, Long form - short form
783 .*---------------------------------------------------------------------*
786 <TC - DECODING [PRIVATE 1] EXPLICIT BOOLEAN, Long form - short form>
794 BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN
796 myBooleanValue BERPDU ::= TRUE
802 import from TempA all;
804 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
809 if (dec_BER_PDU('E181030101FF'O) == myBooleanValue)
812 {setverdict(pass);} else {setverdict(fail);}
817 Overall verdict: pass
823 .*---------------------------------------------------------------------*
824 :h3. DECODING [PRIVATE 1] EXPLICIT BOOLEAN, Long form Long form
825 .*---------------------------------------------------------------------*
828 <TC - DECODING [PRIVATE 1] EXPLICIT BOOLEAN, Long form Long form>
836 BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN
838 myBooleanValue BERPDU ::= TRUE
844 import from TempA all;
846 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
851 if (dec_BER_PDU('E1810401810199'O) == myBooleanValue)
854 {setverdict(pass);} else {setverdict(fail);}
859 Overall verdict: pass
865 .*---------------------------------------------------------------------*
866 :h3. DECODING [APPLICATION 2] EXPLICIT BOOLEAN , DER, Short form - short form
867 .*---------------------------------------------------------------------*
870 <TC - DECODING [APPLICATION 2] EXPLICIT BOOLEAN , DER, Short form - short form>
878 BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN
880 myBooleanValue BERPDU ::= TRUE
886 import from TempA all;
888 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
893 if (dec_BER_PDU('62030101FF'O) == myBooleanValue)
896 {setverdict(pass);} else {setverdict(fail);}
901 Overall verdict: pass
907 .*---------------------------------------------------------------------*
908 :h3. DECODING [APPLICATION 2] EXPLICIT BOOLEAN, CER
909 .*---------------------------------------------------------------------*
912 <TC - DECODING [APPLICATION 2] EXPLICIT BOOLEAN, CER>
920 BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN
922 myBooleanValue BERPDU ::= TRUE
928 import from TempA all;
930 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
935 if (dec_BER_PDU('62800101FF0000'O) == myBooleanValue)
938 {setverdict(pass);} else {setverdict(fail);}
943 Overall verdict: pass
949 .*---------------------------------------------------------------------*
950 :h3. DECODING [APPLICATION 2] EXPLICIT BOOLEAN, Long form - short form
951 .*---------------------------------------------------------------------*
954 <TC - DECODING [APPLICATION 2] EXPLICIT BOOLEAN, Long form - short form>
962 BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN
964 myBooleanValue BERPDU ::= TRUE
970 import from TempA all;
972 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
977 if (dec_BER_PDU('6281030101FF'O) == myBooleanValue)
980 {setverdict(pass);} else {setverdict(fail);}
985 Overall verdict: pass
991 .*---------------------------------------------------------------------*
992 :h3. DECODING [APPLICATION 2] EXPLICIT BOOLEAN, Long form Long form
993 .*---------------------------------------------------------------------*
996 <TC - DECODING [APPLICATION 2] EXPLICIT BOOLEAN, Long form Long form>
1004 BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN
1006 myBooleanValue BERPDU ::= TRUE
1012 import from TempA all;
1014 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
1019 if (dec_BER_PDU('62810401810199'O) == myBooleanValue)
1022 {setverdict(pass);} else {setverdict(fail);}
1027 Overall verdict: pass
1033 .*---------------------------------------------------------------------*
1034 :h3. DECODING [0] IMPLICIT BOOLEAN ,Short form CER,DER
1035 .*---------------------------------------------------------------------*
1038 <TC - DECODING [0] IMPLICIT BOOLEAN ,Short form CER,DER>
1046 BERPDU ::= [0] IMPLICIT BOOLEAN
1048 myBooleanValue BERPDU ::= TRUE
1054 import from TempA all;
1056 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
1061 if (dec_BER_PDU('8001FF'O) == myBooleanValue)
1064 {setverdict(pass);} else {setverdict(fail);}
1069 Overall verdict: pass
1075 .*---------------------------------------------------------------------*
1076 :h3. DECODING [0] IMPLICIT BOOLEAN,Long form
1077 .*---------------------------------------------------------------------*
1080 <TC - DECODING [0] IMPLICIT BOOLEAN,Long form>
1088 BERPDU ::= [0] IMPLICIT BOOLEAN
1090 myBooleanValue BERPDU ::= TRUE
1096 import from TempA all;
1098 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
1103 if (dec_BER_PDU('80810133'O) == myBooleanValue)
1106 {setverdict(pass);} else {setverdict(fail);}
1111 Overall verdict: pass
1117 .*---------------------------------------------------------------------*
1118 :h3. DECODING [PRIVATE 1] IMPLICIT BOOLEAN,Short form CER,DER
1119 .*---------------------------------------------------------------------*
1122 <TC - DECODING [PRIVATE 1] IMPLICIT BOOLEAN,Short form CER,DER>
1130 BERPDU ::= [PRIVATE 1] IMPLICIT BOOLEAN
1132 myBooleanValue BERPDU ::= FALSE
1138 import from TempA all;
1140 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
1145 if (dec_BER_PDU('C10100'O) == myBooleanValue)
1148 {setverdict(pass);} else {setverdict(fail);}
1153 Overall verdict: pass
1159 .*---------------------------------------------------------------------*
1160 :h3. DECODING [PRIVATE 1] IMPLICIT BOOLEAN,Long form
1161 .*---------------------------------------------------------------------*
1164 <TC - DECODING [PRIVATE 1] IMPLICIT BOOLEAN,Long form>
1172 BERPDU ::= [PRIVATE 1] IMPLICIT BOOLEAN
1174 myBooleanValue BERPDU ::= TRUE
1180 import from TempA all;
1182 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
1187 if (dec_BER_PDU('C1810105'O) == myBooleanValue)
1190 {setverdict(pass);} else {setverdict(fail);}
1195 Overall verdict: pass
1201 .*---------------------------------------------------------------------*
1202 :h3. DECODING [APPLICATION 2] IMPLICIT BOOLEAN,Short form CER,DER
1203 .*---------------------------------------------------------------------*
1206 <TC - DECODING [APPLICATION 2] IMPLICIT BOOLEAN,Short form CER,DER>
1214 BERPDU ::= [APPLICATION 2] IMPLICIT BOOLEAN
1216 myBooleanValue BERPDU ::= FALSE
1222 import from TempA all;
1224 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
1229 if (dec_BER_PDU('420100'O) == myBooleanValue)
1232 {setverdict(pass);} else {setverdict(fail);}
1237 Overall verdict: pass
1243 .*---------------------------------------------------------------------*
1244 :h3. DECODING [APPLICATION 2] IMPLICIT BOOLEAN,Long form
1245 .*---------------------------------------------------------------------*
1248 <TC - DECODING [APPLICATION 2] IMPLICIT BOOLEAN,Long form>
1256 BERPDU ::= [APPLICATION 2] IMPLICIT BOOLEAN
1258 myBooleanValue BERPDU ::= TRUE
1264 import from TempA all;
1266 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
1271 if (dec_BER_PDU('42810188'O) == myBooleanValue)
1274 {setverdict(pass);} else {setverdict(fail);}
1279 Overall verdict: pass
1285 .*---------------------------------------------------------------------*
1286 :h3. DER + CER encoding of integer (5)
1287 .*---------------------------------------------------------------------*
1290 <TC - DER + CER encoding of integer (5)>
1291 START OF INTEGER SECTION
1304 import from TempA all;
1305 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1306 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1312 if ((enc_DER_PDU(b) == '020105'O)and(enc_CER_PDU(b) == '020105'O)) {setverdict(pass);} else {setverdict(fail);}
1316 Overall verdict: pass
1322 .*---------------------------------------------------------------------*
1323 :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT
1324 .*---------------------------------------------------------------------*
1327 <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT>
1335 BERPDU ::= [0] EXPLICIT INTEGER
1340 import from TempA all;
1341 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1342 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1348 if ((enc_DER_PDU(b) == 'A003020105'O)and(enc_CER_PDU(b) == 'A0800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
1352 Overall verdict: pass
1358 .*---------------------------------------------------------------------*
1359 :h3. DER + CER encoding of integer (5) with PRIVATE TAG, EXPLICIT
1360 .*---------------------------------------------------------------------*
1363 <TC - DER + CER encoding of integer (5) with PRIVATE TAG, EXPLICIT>
1371 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
1376 import from TempA all;
1377 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1378 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1384 if ((enc_DER_PDU(b) == 'E103020105'O)and(enc_CER_PDU(b) == 'E1800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
1388 Overall verdict: pass
1394 .*---------------------------------------------------------------------*
1395 :h3. DER + CER encoding of integer (5) with APPLICATION TAG, EXPLICIT
1396 .*---------------------------------------------------------------------*
1399 <TC - DER + CER encoding of integer (5) with APPLICATION TAG, EXPLICIT>
1407 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
1412 import from TempA all;
1413 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1414 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1420 if ((enc_DER_PDU(b) == '6203020105'O)and(enc_CER_PDU(b) == '62800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
1424 Overall verdict: pass
1430 .*---------------------------------------------------------------------*
1431 :h3. DER + CER encoding of integer (5) with Context Specific TAG, IMPLICIT
1432 .*---------------------------------------------------------------------*
1435 <TC - DER + CER encoding of integer (5) with Context Specific TAG, IMPLICIT>
1443 BERPDU ::= [0] IMPLICIT INTEGER
1448 import from TempA all;
1449 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1450 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1456 if ((enc_DER_PDU(b) == '800105'O)and(enc_CER_PDU(b) == '800105'O)) {setverdict(pass);} else {setverdict(fail);}
1460 Overall verdict: pass
1466 .*---------------------------------------------------------------------*
1467 :h3. DER + CER encoding of integer (5) with PRIVATE TAG, IMPLICIT
1468 .*---------------------------------------------------------------------*
1471 <TC - DER + CER encoding of integer (5) with PRIVATE TAG, IMPLICIT>
1479 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
1484 import from TempA all;
1485 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1486 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1492 if ((enc_DER_PDU(b) == 'C10105'O)and(enc_CER_PDU(b) == 'C10105'O)) {setverdict(pass);} else {setverdict(fail);}
1496 Overall verdict: pass
1502 .*---------------------------------------------------------------------*
1503 :h3. DER + CER encoding of integer (5) with APPLICATION TAG, IMPLICIT
1504 .*---------------------------------------------------------------------*
1507 <TC - DER + CER encoding of integer (5) with APPLICATION TAG, IMPLICIT>
1515 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
1520 import from TempA all;
1521 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1522 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1528 if ((enc_DER_PDU(b) == '420105'O)and(enc_CER_PDU(b) == '420105'O)) {setverdict(pass);} else {setverdict(fail);}
1532 Overall verdict: pass
1538 .*---------------------------------------------------------------------*
1539 :h3. DER + CER encoding of integer (0)
1540 .*---------------------------------------------------------------------*
1543 <TC - DER + CER encoding of integer (0) >
1556 import from TempA all;
1557 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1558 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1564 if ((enc_DER_PDU(b) == '020100'O)and(enc_CER_PDU(b) == '020100'O)) {setverdict(pass);} else {setverdict(fail);}
1568 Overall verdict: pass
1574 .*---------------------------------------------------------------------*
1575 :h3. DER + CER encoding of integer (0) with Context Specific TAG, EXPLICIT
1576 .*---------------------------------------------------------------------*
1579 <TC - DER + CER encoding of integer (0) with Context Specific TAG, EXPLICIT>
1587 BERPDU ::= [0] EXPLICIT INTEGER
1592 import from TempA all;
1593 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1594 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1600 if ((enc_DER_PDU(b) == 'A003020100'O)and(enc_CER_PDU(b) == 'A0800201000000'O)) {setverdict(pass);} else {setverdict(fail);}
1604 Overall verdict: pass
1610 .*---------------------------------------------------------------------*
1611 :h3. DER + CER encoding of integer (0) with PRIVATE TAG, EXPLICIT
1612 .*---------------------------------------------------------------------*
1615 <TC - DER + CER encoding of integer (0) with PRIVATE TAG, EXPLICIT>
1623 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
1628 import from TempA all;
1629 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1630 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1636 if ((enc_DER_PDU(b) == 'E103020100'O)and(enc_CER_PDU(b) == 'E1800201000000'O)) {setverdict(pass);} else {setverdict(fail);}
1640 Overall verdict: pass
1646 .*---------------------------------------------------------------------*
1647 :h3. DER + CER encoding of integer (0) with APPLICATION TAG, EXPLICIT
1648 .*---------------------------------------------------------------------*
1651 <TC - DER + CER encoding of integer (0) with APPLICATION TAG, EXPLICIT>
1659 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
1664 import from TempA all;
1665 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1666 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1672 if ((enc_DER_PDU(b) == '6203020100'O)and(enc_CER_PDU(b) == '62800201000000'O)) {setverdict(pass);} else {setverdict(fail);}
1676 Overall verdict: pass
1682 .*---------------------------------------------------------------------*
1683 :h3. DER + CER encoding of integer (0) with Context Specific TAG, IMPLICIT
1684 .*---------------------------------------------------------------------*
1687 <TC - DER + CER encoding of integer (0) with Context Specific TAG, IMPLICIT>
1695 BERPDU ::= [0] IMPLICIT INTEGER
1700 import from TempA all;
1701 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1702 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1708 if ((enc_DER_PDU(b) == '800100'O)and(enc_CER_PDU(b) == '800100'O)) {setverdict(pass);} else {setverdict(fail);}
1712 Overall verdict: pass
1718 .*---------------------------------------------------------------------*
1719 :h3. DER + CER encoding of integer (0) with PRIVATE TAG, IMPLICIT
1720 .*---------------------------------------------------------------------*
1723 <TC - DER + CER encoding of integer (0) with PRIVATE TAG, IMPLICIT>
1731 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
1736 import from TempA all;
1737 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1738 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1744 if ((enc_DER_PDU(b) == 'C10100'O)and(enc_CER_PDU(b) == 'C10100'O)) {setverdict(pass);} else {setverdict(fail);}
1748 Overall verdict: pass
1754 .*---------------------------------------------------------------------*
1755 :h3. DER + CER encoding of integer (0) with APPLICATION TAG, IMPLICIT
1756 .*---------------------------------------------------------------------*
1759 <TC - DER + CER encoding of integer (0) with APPLICATION TAG, IMPLICIT>
1767 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
1772 import from TempA all;
1773 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1774 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1780 if ((enc_DER_PDU(b) == '420100'O)and(enc_CER_PDU(b) == '420100'O)) {setverdict(pass);} else {setverdict(fail);}
1784 Overall verdict: pass
1790 .*---------------------------------------------------------------------*
1791 :h3. DER + CER encoding of integer (127)
1792 .*---------------------------------------------------------------------*
1795 <TC - DER + CER encoding of integer (127) >
1808 import from TempA all;
1809 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1810 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1812 const BERPDU b := 127
1816 if ((enc_DER_PDU(b) == '02017F'O)and(enc_CER_PDU(b) == '02017F'O)) {setverdict(pass);} else {setverdict(fail);}
1820 Overall verdict: pass
1826 .*---------------------------------------------------------------------*
1827 :h3. DER + CER encoding of integer (127) with Context Specific TAG, EXPLICIT
1828 .*---------------------------------------------------------------------*
1831 <TC - DER + CER encoding of integer (127) with Context Specific TAG, EXPLICIT>
1839 BERPDU ::= [0] EXPLICIT INTEGER
1844 import from TempA all;
1845 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1846 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1848 const BERPDU b := 127
1852 if ((enc_DER_PDU(b) == 'A00302017F'O)and(enc_CER_PDU(b) == 'A08002017F0000'O)) {setverdict(pass);} else {setverdict(fail);}
1856 Overall verdict: pass
1862 .*---------------------------------------------------------------------*
1863 :h3. DER + CER encoding of integer (127) with PRIVATE TAG, EXPLICIT
1864 .*---------------------------------------------------------------------*
1867 <TC - DER + CER encoding of integer (127) with PRIVATE TAG, EXPLICIT>
1875 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
1880 import from TempA all;
1881 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1882 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1884 const BERPDU b := 127
1888 if ((enc_DER_PDU(b) == 'E10302017F'O)and(enc_CER_PDU(b) == 'E18002017F0000'O)) {setverdict(pass);} else {setverdict(fail);}
1892 Overall verdict: pass
1898 .*---------------------------------------------------------------------*
1899 :h3. DER + CER encoding of integer (127) with APPLICATION TAG, EXPLICIT
1900 .*---------------------------------------------------------------------*
1903 <TC - DER + CER encoding of integer (127) with APPLICATION TAG, EXPLICIT>
1911 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
1916 import from TempA all;
1917 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1918 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1920 const BERPDU b := 127
1924 if ((enc_DER_PDU(b) == '620302017F'O)and(enc_CER_PDU(b) == '628002017F0000'O)) {setverdict(pass);} else {setverdict(fail);}
1928 Overall verdict: pass
1934 .*---------------------------------------------------------------------*
1935 :h3. DER + CER encoding of integer (127) with Context Specific TAG, IMPLICIT
1936 .*---------------------------------------------------------------------*
1939 <TC - DER + CER encoding of integer (127) with Context Specific TAG, IMPLICIT>
1947 BERPDU ::= [0] IMPLICIT INTEGER
1952 import from TempA all;
1953 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1954 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1956 const BERPDU b := 127
1960 if ((enc_DER_PDU(b) == '80017F'O)and(enc_CER_PDU(b) == '80017F'O)) {setverdict(pass);} else {setverdict(fail);}
1964 Overall verdict: pass
1970 .*---------------------------------------------------------------------*
1971 :h3. DER + CER encoding of integer (127) with PRIVATE TAG, IMPLICIT
1972 .*---------------------------------------------------------------------*
1975 <TC - DER + CER encoding of integer (127) with PRIVATE TAG, IMPLICIT>
1983 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
1988 import from TempA all;
1989 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1990 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1992 const BERPDU b := 127
1996 if ((enc_DER_PDU(b) == 'C1017F'O)and(enc_CER_PDU(b) == 'C1017F'O)) {setverdict(pass);} else {setverdict(fail);}
2000 Overall verdict: pass
2006 .*---------------------------------------------------------------------*
2007 :h3. DER + CER encoding of integer (127) with APPLICATION TAG, IMPLICIT
2008 .*---------------------------------------------------------------------*
2011 <TC - DER + CER encoding of integer (127) with APPLICATION TAG, IMPLICIT>
2019 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
2024 import from TempA all;
2025 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2026 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2028 const BERPDU b := 127
2032 if ((enc_DER_PDU(b) == '42017F'O)and(enc_CER_PDU(b) == '42017F'O)) {setverdict(pass);} else {setverdict(fail);}
2036 Overall verdict: pass
2042 .*---------------------------------------------------------------------*
2043 :h3. DER + CER encoding of integer (-128)
2044 .*---------------------------------------------------------------------*
2047 <TC - DER + CER encoding of integer (-128) >
2060 import from TempA all;
2061 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2062 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2064 const BERPDU b := -128
2068 if ((enc_DER_PDU(b) == '020180'O)and(enc_CER_PDU(b) == '020180'O)) {setverdict(pass);} else {setverdict(fail);}
2072 Overall verdict: pass
2078 .*---------------------------------------------------------------------*
2079 :h3. DER + CER encoding of integer (-128) with Context Specific TAG, EXPLICIT
2080 .*---------------------------------------------------------------------*
2083 <TC - DER + CER encoding of integer (-128) with Context Specific TAG, EXPLICIT>
2091 BERPDU ::= [0] EXPLICIT INTEGER
2096 import from TempA all;
2097 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2098 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2100 const BERPDU b := -128
2104 if ((enc_DER_PDU(b) == 'A003020180'O)and(enc_CER_PDU(b) == 'A0800201800000'O)) {setverdict(pass);} else {setverdict(fail);}
2108 Overall verdict: pass
2114 .*---------------------------------------------------------------------*
2115 :h3. DER + CER encoding of integer (-128) with PRIVATE TAG, EXPLICIT
2116 .*---------------------------------------------------------------------*
2119 <TC - DER + CER encoding of integer (-128) with PRIVATE TAG, EXPLICIT>
2127 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
2132 import from TempA all;
2133 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2134 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2136 const BERPDU b := -128
2140 if ((enc_DER_PDU(b) == 'E103020180'O)and(enc_CER_PDU(b) == 'E1800201800000'O)) {setverdict(pass);} else {setverdict(fail);}
2144 Overall verdict: pass
2150 .*---------------------------------------------------------------------*
2151 :h3. DER + CER encoding of integer (-128) with APPLICATION TAG, EXPLICIT
2152 .*---------------------------------------------------------------------*
2155 <TC - DER + CER encoding of integer (-128) with APPLICATION TAG, EXPLICIT>
2163 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
2168 import from TempA all;
2169 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2170 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2172 const BERPDU b := -128
2176 if ((enc_DER_PDU(b) == '6203020180'O)and(enc_CER_PDU(b) == '62800201800000'O)) {setverdict(pass);} else {setverdict(fail);}
2180 Overall verdict: pass
2186 .*---------------------------------------------------------------------*
2187 :h3. DER + CER encoding of integer (-128) with Context Specific TAG, IMPLICIT
2188 .*---------------------------------------------------------------------*
2191 <TC - DER + CER encoding of integer (-128) with Context Specific TAG, IMPLICIT>
2199 BERPDU ::= [0] IMPLICIT INTEGER
2204 import from TempA all;
2205 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2206 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2208 const BERPDU b := -128
2212 if ((enc_DER_PDU(b) == '800180'O)and(enc_CER_PDU(b) == '800180'O)) {setverdict(pass);} else {setverdict(fail);}
2216 Overall verdict: pass
2222 .*---------------------------------------------------------------------*
2223 :h3. DER + CER encoding of integer (-128) with PRIVATE TAG, IMPLICIT
2224 .*---------------------------------------------------------------------*
2227 <TC - DER + CER encoding of integer (-128) with PRIVATE TAG, IMPLICIT>
2235 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
2240 import from TempA all;
2241 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2242 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2244 const BERPDU b := -128
2248 if ((enc_DER_PDU(b) == 'C10180'O)and(enc_CER_PDU(b) == 'C10180'O)) {setverdict(pass);} else {setverdict(fail);}
2252 Overall verdict: pass
2258 .*---------------------------------------------------------------------*
2259 :h3. DER + CER encoding of integer (-128) with APPLICATION TAG, IMPLICIT
2260 .*---------------------------------------------------------------------*
2263 <TC - DER + CER encoding of integer (-128) with APPLICATION TAG, IMPLICIT>
2271 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
2276 import from TempA all;
2277 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2278 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2280 const BERPDU b := -128
2284 if ((enc_DER_PDU(b) == '420180'O)and(enc_CER_PDU(b) == '420180'O)) {setverdict(pass);} else {setverdict(fail);}
2288 Overall verdict: pass
2294 .*---------------------------------------------------------------------*
2295 :h3. DER + CER encoding of integer (-5)
2296 .*---------------------------------------------------------------------*
2299 <TC - DER + CER encoding of integer (-5)>
2312 import from TempA all;
2313 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2314 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2316 const BERPDU b := -5
2320 if ((enc_DER_PDU(b) == '0201FB'O)and(enc_CER_PDU(b) == '0201FB'O)) {setverdict(pass);} else {setverdict(fail);}
2324 Overall verdict: pass
2330 .*---------------------------------------------------------------------*
2331 :h3. DER + CER encoding of integer (-5) with Context Specific TAG, EXPLICIT
2332 .*---------------------------------------------------------------------*
2335 <TC - DER + CER encoding of integer (-5) with Context Specific TAG, EXPLICIT>
2343 BERPDU ::= [0] EXPLICIT INTEGER
2348 import from TempA all;
2349 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2350 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2352 const BERPDU b := -5
2356 if ((enc_DER_PDU(b) == 'A0030201FB'O)and(enc_CER_PDU(b) == 'A0800201FB0000'O)) {setverdict(pass);} else {setverdict(fail);}
2360 Overall verdict: pass
2366 .*---------------------------------------------------------------------*
2367 :h3. DER + CER encoding of integer (-5) with PRIVATE TAG, EXPLICIT
2368 .*---------------------------------------------------------------------*
2371 <TC - DER + CER encoding of integer (-5) with PRIVATE TAG, EXPLICIT>
2379 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
2384 import from TempA all;
2385 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2386 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2388 const BERPDU b := -5
2392 if ((enc_DER_PDU(b) == 'E1030201FB'O)and(enc_CER_PDU(b) == 'E1800201FB0000'O)) {setverdict(pass);} else {setverdict(fail);}
2396 Overall verdict: pass
2402 .*---------------------------------------------------------------------*
2403 :h3. DER + CER encoding of integer (-5) with APPLICATION TAG, EXPLICIT
2404 .*---------------------------------------------------------------------*
2407 <TC - DER + CER encoding of integer (-5) with APPLICATION TAG, EXPLICIT>
2415 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
2420 import from TempA all;
2421 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2422 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2424 const BERPDU b := -5
2428 if ((enc_DER_PDU(b) == '62030201FB'O)and(enc_CER_PDU(b) == '62800201FB0000'O)) {setverdict(pass);} else {setverdict(fail);}
2432 Overall verdict: pass
2438 .*---------------------------------------------------------------------*
2439 :h3. DER + CER encoding of integer (-5) with Context Specific TAG, IMPLICIT
2440 .*---------------------------------------------------------------------*
2443 <TC - DER + CER encoding of integer (-5) with Context Specific TAG, IMPLICIT>
2451 BERPDU ::= [0] IMPLICIT INTEGER
2456 import from TempA all;
2457 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2458 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2460 const BERPDU b := -5
2464 if ((enc_DER_PDU(b) == '8001FB'O)and(enc_CER_PDU(b) == '8001FB'O)) {setverdict(pass);} else {setverdict(fail);}
2468 Overall verdict: pass
2474 .*---------------------------------------------------------------------*
2475 :h3. DER + CER encoding of integer (-5) with PRIVATE TAG, IMPLICIT
2476 .*---------------------------------------------------------------------*
2479 <TC - DER + CER encoding of integer (-5) with PRIVATE TAG, IMPLICIT>
2487 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
2492 import from TempA all;
2493 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2494 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2496 const BERPDU b := -5
2500 if ((enc_DER_PDU(b) == 'C101FB'O)and(enc_CER_PDU(b) == 'C101FB'O)) {setverdict(pass);} else {setverdict(fail);}
2504 Overall verdict: pass
2510 .*---------------------------------------------------------------------*
2511 :h3. DER + CER encoding of integer (-5) with APPLICATION TAG, IMPLICIT
2512 .*---------------------------------------------------------------------*
2515 <TC - DER + CER encoding of integer (-5) with APPLICATION TAG, IMPLICIT>
2523 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
2528 import from TempA all;
2529 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2530 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2532 const BERPDU b := -5
2536 if ((enc_DER_PDU(b) == '4201FB'O)and(enc_CER_PDU(b) == '4201FB'O)) {setverdict(pass);} else {setverdict(fail);}
2540 Overall verdict: pass
2546 .*---------------------------------------------------------------------*
2547 :h3. DER + CER encoding of integer (128)
2548 .*---------------------------------------------------------------------*
2551 <TC - DER + CER encoding of integer (128)>
2564 import from TempA all;
2565 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2566 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2568 const BERPDU b := 128
2572 if ((enc_DER_PDU(b) == '02020080'O)and(enc_CER_PDU(b) == '02020080'O)) {setverdict(pass);} else {setverdict(fail);}
2576 Overall verdict: pass
2582 .*---------------------------------------------------------------------*
2583 :h3. DER + CER encoding of integer (128) with Context Specific TAG, EXPLICIT
2584 .*---------------------------------------------------------------------*
2587 <TC - DER + CER encoding of integer (128) with Context Specific TAG, EXPLICIT>
2595 BERPDU ::= [0] EXPLICIT INTEGER
2600 import from TempA all;
2601 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2602 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2604 const BERPDU b := 128
2608 if ((enc_DER_PDU(b) == 'A00402020080'O)and(enc_CER_PDU(b) == 'A080020200800000'O)) {setverdict(pass);} else {setverdict(fail);}
2612 Overall verdict: pass
2618 .*---------------------------------------------------------------------*
2619 :h3. DER + CER encoding of integer (128) with PRIVATE TAG, EXPLICIT
2620 .*---------------------------------------------------------------------*
2623 <TC - DER + CER encoding of integer (128) with PRIVATE TAG, EXPLICIT>
2631 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
2636 import from TempA all;
2637 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2638 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2640 const BERPDU b := 128
2644 if ((enc_DER_PDU(b) == 'E10402020080'O)and(enc_CER_PDU(b) == 'E180020200800000'O)) {setverdict(pass);} else {setverdict(fail);}
2648 Overall verdict: pass
2654 .*---------------------------------------------------------------------*
2655 :h3. DER + CER encoding of integer (128) with APPLICATION TAG, EXPLICIT
2656 .*---------------------------------------------------------------------*
2659 <TC - DER + CER encoding of integer (128) with APPLICATION TAG, EXPLICIT>
2667 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
2672 import from TempA all;
2673 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2674 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2676 const BERPDU b := 128
2680 if ((enc_DER_PDU(b) == '620402020080'O)and(enc_CER_PDU(b) == '6280020200800000'O)) {setverdict(pass);} else {setverdict(fail);}
2684 Overall verdict: pass
2690 .*---------------------------------------------------------------------*
2691 :h3. DER + CER encoding of integer (128) with Context Specific TAG, IMPLICIT
2692 .*---------------------------------------------------------------------*
2695 <TC - DER + CER encoding of integer (128) with Context Specific TAG, IMPLICIT>
2703 BERPDU ::= [0] IMPLICIT INTEGER
2708 import from TempA all;
2709 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2710 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2712 const BERPDU b := 128
2716 if ((enc_DER_PDU(b) == '80020080'O)and(enc_CER_PDU(b) == '80020080'O)) {setverdict(pass);} else {setverdict(fail);}
2720 Overall verdict: pass
2726 .*---------------------------------------------------------------------*
2727 :h3. DER + CER encoding of integer (128) with PRIVATE TAG, IMPLICIT
2728 .*---------------------------------------------------------------------*
2731 <TC - DER + CER encoding of integer (128) with PRIVATE TAG, IMPLICIT>
2739 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
2744 import from TempA all;
2745 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2746 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2748 const BERPDU b := 128
2752 if ((enc_DER_PDU(b) == 'C1020080'O)and(enc_CER_PDU(b) == 'C1020080'O)) {setverdict(pass);} else {setverdict(fail);}
2756 Overall verdict: pass
2762 .*---------------------------------------------------------------------*
2763 :h3. DER + CER encoding of integer (128) with APPLICATION TAG, IMPLICIT
2764 .*---------------------------------------------------------------------*
2767 <TC - DER + CER encoding of integer (128) with APPLICATION TAG, IMPLICIT>
2775 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
2780 import from TempA all;
2781 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2782 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2784 const BERPDU b := 128
2788 if ((enc_DER_PDU(b) == '42020080'O)and(enc_CER_PDU(b) == '42020080'O)) {setverdict(pass);} else {setverdict(fail);}
2792 Overall verdict: pass
2798 .*---------------------------------------------------------------------*
2799 :h3. DER + CER encoding of integer (-129)
2800 .*---------------------------------------------------------------------*
2803 <TC - DER + CER encoding of integer (-129)>
2816 import from TempA all;
2817 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2818 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2820 const BERPDU b := -129
2824 if ((enc_DER_PDU(b) == '0202FF7F'O)and(enc_CER_PDU(b) == '0202FF7F'O)) {setverdict(pass);} else {setverdict(fail);}
2828 Overall verdict: pass
2834 .*---------------------------------------------------------------------*
2835 :h3. DER + CER encoding of integer (-129) with Context Specific TAG, EXPLICIT
2836 .*---------------------------------------------------------------------*
2839 <TC - DER + CER encoding of integer (-129) with Context Specific TAG, EXPLICIT>
2847 BERPDU ::= [0] EXPLICIT INTEGER
2852 import from TempA all;
2853 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2854 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2856 const BERPDU b := -129
2860 if ((enc_DER_PDU(b) == 'A0040202FF7F'O)and(enc_CER_PDU(b) == 'A0800202FF7F0000'O)) {setverdict(pass);} else {setverdict(fail);}
2864 Overall verdict: pass
2870 .*---------------------------------------------------------------------*
2871 :h3. DER + CER encoding of integer (-129) with PRIVATE TAG, EXPLICIT
2872 .*---------------------------------------------------------------------*
2875 <TC - DER + CER encoding of integer (-129) with PRIVATE TAG, EXPLICIT>
2883 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
2888 import from TempA all;
2889 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2890 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2892 const BERPDU b := -129
2896 if ((enc_DER_PDU(b) == 'E1040202FF7F'O)and(enc_CER_PDU(b) == 'E1800202FF7F0000'O)) {setverdict(pass);} else {setverdict(fail);}
2900 Overall verdict: pass
2906 .*---------------------------------------------------------------------*
2907 :h3. DER + CER encoding of integer (-129) with APPLICATION TAG, EXPLICIT
2908 .*---------------------------------------------------------------------*
2911 <TC - DER + CER encoding of integer (-129) with APPLICATION TAG, EXPLICIT>
2919 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
2924 import from TempA all;
2925 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2926 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2928 const BERPDU b := -129
2932 if ((enc_DER_PDU(b) == '62040202FF7F'O)and(enc_CER_PDU(b) == '62800202FF7F0000'O)) {setverdict(pass);} else {setverdict(fail);}
2936 Overall verdict: pass
2942 .*---------------------------------------------------------------------*
2943 :h3. DER + CER encoding of integer (-129) with Context Specific TAG, IMPLICIT
2944 .*---------------------------------------------------------------------*
2947 <TC - DER + CER encoding of integer (-129) with Context Specific TAG, IMPLICIT>
2955 BERPDU ::= [0] IMPLICIT INTEGER
2960 import from TempA all;
2961 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2962 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2964 const BERPDU b := -129
2968 if ((enc_DER_PDU(b) == '8002FF7F'O)and(enc_CER_PDU(b) == '8002FF7F'O)) {setverdict(pass);} else {setverdict(fail);}
2972 Overall verdict: pass
2978 .*---------------------------------------------------------------------*
2979 :h3. DER + CER encoding of integer (-129) with PRIVATE TAG, IMPLICIT
2980 .*---------------------------------------------------------------------*
2983 <TC - DER + CER encoding of integer (-129) with PRIVATE TAG, IMPLICIT>
2991 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
2996 import from TempA all;
2997 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2998 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3000 const BERPDU b := -129
3004 if ((enc_DER_PDU(b) == 'C102FF7F'O)and(enc_CER_PDU(b) == 'C102FF7F'O)) {setverdict(pass);} else {setverdict(fail);}
3008 Overall verdict: pass
3014 .*---------------------------------------------------------------------*
3015 :h3. DER + CER encoding of integer (-129) with APPLICATION TAG, IMPLICIT
3016 .*---------------------------------------------------------------------*
3019 <TC - DER + CER encoding of integer (-129) with APPLICATION TAG, IMPLICIT>
3027 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
3032 import from TempA all;
3033 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3034 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3036 const BERPDU b := -129
3040 if ((enc_DER_PDU(b) == '4202FF7F'O)and(enc_CER_PDU(b) == '4202FF7F'O)) {setverdict(pass);} else {setverdict(fail);}
3044 Overall verdict: pass
3050 .*---------------------------------------------------------------------*
3051 :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT
3052 .*---------------------------------------------------------------------*
3055 <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT>
3065 BERPDU ::= [30] EXPLICIT INTEGER
3070 import from TempA all;
3071 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3072 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3078 if ((enc_DER_PDU(b) == 'BE03020105'O)and(enc_CER_PDU(b) == 'BE800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
3082 Overall verdict: pass
3088 .*---------------------------------------------------------------------*
3089 :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT
3090 .*---------------------------------------------------------------------*
3093 <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT>
3103 BERPDU ::= [31] EXPLICIT INTEGER
3108 import from TempA all;
3109 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3110 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3116 if ((enc_DER_PDU(b) == 'BF1F03020105'O)and(enc_CER_PDU(b) == 'BF1F800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
3120 Overall verdict: pass
3126 .*---------------------------------------------------------------------*
3127 :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT
3128 .*---------------------------------------------------------------------*
3131 <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT>
3141 BERPDU ::= [127] EXPLICIT INTEGER
3146 import from TempA all;
3147 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3148 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3154 if ((enc_DER_PDU(b) == 'BF7F03020105'O)and(enc_CER_PDU(b) == 'BF7F800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
3158 Overall verdict: pass
3164 .*---------------------------------------------------------------------*
3165 :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT
3166 .*---------------------------------------------------------------------*
3169 <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT>
3179 BERPDU ::= [128] EXPLICIT INTEGER
3184 import from TempA all;
3185 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3186 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3192 if ((enc_DER_PDU(b) == 'BF810003020105'O)and(enc_CER_PDU(b) == 'BF8100800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
3196 Overall verdict: pass
3202 .*---------------------------------------------------------------------*
3203 :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT
3204 .*---------------------------------------------------------------------*
3207 <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT>
3217 BERPDU ::= [16383] EXPLICIT INTEGER
3222 import from TempA all;
3223 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3224 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3230 if ((enc_DER_PDU(b) == 'BFFF7F03020105'O)and(enc_CER_PDU(b) == 'BFFF7F800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
3234 Overall verdict: pass
3240 .*---------------------------------------------------------------------*
3241 :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT
3242 .*---------------------------------------------------------------------*
3245 <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT>
3255 BERPDU ::= [16384] EXPLICIT INTEGER
3260 import from TempA all;
3261 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3262 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3268 if ((enc_DER_PDU(b) == 'BF81800003020105'O)and(enc_CER_PDU(b) == 'BF818000800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
3272 Overall verdict: pass
3278 .*---------------------------------------------------------------------*
3279 :h3. DECODING INTEGER (5), CER+DER
3280 .*---------------------------------------------------------------------*
3283 <TC - DECODING INTEGER (5), CER+DER>
3293 myIntegerValue BERPDU ::= 5
3299 import from TempA all;
3301 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3306 if (dec_BER_PDU('020105'O) == myIntegerValue)
3309 {setverdict(pass);} else {setverdict(fail);}
3314 Overall verdict: pass
3320 .*---------------------------------------------------------------------*
3321 :h3. DECODING INTEGER (5), (LENGTH OF LENGTH = 1)
3322 .*---------------------------------------------------------------------*
3325 <TC - DECODING INTEGER (5), (LENGTH OF LENGTH = 1)>
3335 myIntegerValue BERPDU ::= 5
3341 import from TempA all;
3343 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3348 if (dec_BER_PDU('02810105'O) == myIntegerValue)
3351 {setverdict(pass);} else {setverdict(fail);}
3356 Overall verdict: pass
3362 .*---------------------------------------------------------------------*
3363 :h3. DECODING INTEGER (5), (LENGTH OF LENGTH = 2)
3364 .*---------------------------------------------------------------------*
3367 <TC - DECODING INTEGER (5), (LENGTH OF LENGTH = 2)>
3377 myIntegerValue BERPDU ::= 5
3383 import from TempA all;
3385 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3390 if (dec_BER_PDU('0282000105'O) == myIntegerValue)
3393 {setverdict(pass);} else {setverdict(fail);}
3398 Overall verdict: pass
3404 .*---------------------------------------------------------------------*
3405 :h3. DECODING [0] EXPLICIT INTEGER (5), DER
3406 .*---------------------------------------------------------------------*
3409 <TC - DECODING [0] EXPLICIT INTEGER (5), DER>
3417 BERPDU ::= [0] EXPLICIT INTEGER
3419 myIntegerValue BERPDU ::= 5
3425 import from TempA all;
3427 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3432 if (dec_BER_PDU('A003020105'O) == myIntegerValue)
3435 {setverdict(pass);} else {setverdict(fail);}
3440 Overall verdict: pass
3446 .*---------------------------------------------------------------------*
3447 :h3. DECODING [0] EXPLICIT INTEGER (5), CER
3448 .*---------------------------------------------------------------------*
3451 <TC - DECODING [0] EXPLICIT INTEGER (5), CER>
3459 BERPDU ::= [0] EXPLICIT INTEGER
3461 myIntegerValue BERPDU ::= 5
3467 import from TempA all;
3469 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3474 if (dec_BER_PDU('A0800201050000'O) == myIntegerValue)
3477 {setverdict(pass);} else {setverdict(fail);}
3482 Overall verdict: pass
3488 .*---------------------------------------------------------------------*
3489 :h3. DECODING [0] EXPLICIT INTEGER (5), Short form - long form
3490 .*---------------------------------------------------------------------*
3493 <TC - DECODING [0] EXPLICIT INTEGER (5), Short form - long form>
3501 BERPDU ::= [0] EXPLICIT INTEGER
3503 myIntegerValue BERPDU ::= 5
3509 import from TempA all;
3511 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3516 if (dec_BER_PDU('A003020105'O) == myIntegerValue)
3519 {setverdict(pass);} else {setverdict(fail);}
3524 Overall verdict: pass
3530 .*---------------------------------------------------------------------*
3531 :h3. DECODING [0] EXPLICIT INTEGER (5), Long form - short form
3532 .*---------------------------------------------------------------------*
3535 <TC - DECODING [0] EXPLICIT INTEGER (5), Long form - short form>
3543 BERPDU ::= [0] EXPLICIT INTEGER
3545 myIntegerValue BERPDU ::= 5
3551 import from TempA all;
3553 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3558 if (dec_BER_PDU('A08103020105'O) == myIntegerValue)
3561 {setverdict(pass);} else {setverdict(fail);}
3566 Overall verdict: pass
3572 .*---------------------------------------------------------------------*
3573 :h3. DECODING [0] EXPLICIT INTEGER (5), Long form Long form
3574 .*---------------------------------------------------------------------*
3577 <TC - DECODING [0] EXPLICIT INTEGER (5), Long form Long form>
3585 BERPDU ::= [0] EXPLICIT INTEGER
3587 myIntegerValue BERPDU ::= 5
3593 import from TempA all;
3595 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3600 if (dec_BER_PDU('A0810402810105'O) == myIntegerValue)
3603 {setverdict(pass);} else {setverdict(fail);}
3608 Overall verdict: pass
3614 .*---------------------------------------------------------------------*
3615 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Short form - Short form, DER
3616 .*---------------------------------------------------------------------*
3619 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Short form - Short form, DER>
3627 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
3629 myIntegerValue BERPDU ::= 5
3635 import from TempA all;
3637 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3642 if (dec_BER_PDU('E103020105'O) == myIntegerValue)
3645 {setverdict(pass);} else {setverdict(fail);}
3650 Overall verdict: pass
3656 .*---------------------------------------------------------------------*
3657 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Short form - long form
3658 .*---------------------------------------------------------------------*
3661 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Short form - long form>
3669 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
3671 myIntegerValue BERPDU ::= 5
3677 import from TempA all;
3679 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3684 if (dec_BER_PDU('E10402810105'O) == myIntegerValue)
3687 {setverdict(pass);} else {setverdict(fail);}
3692 Overall verdict: pass
3698 .*---------------------------------------------------------------------*
3699 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Long form - short form
3700 .*---------------------------------------------------------------------*
3703 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Long form - short form>
3711 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
3713 myIntegerValue BERPDU ::= 5
3719 import from TempA all;
3721 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3726 if (dec_BER_PDU('E18103020105'O) == myIntegerValue)
3729 {setverdict(pass);} else {setverdict(fail);}
3734 Overall verdict: pass
3740 .*---------------------------------------------------------------------*
3741 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Long form Long form
3742 .*---------------------------------------------------------------------*
3745 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Long form Long form>
3753 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
3755 myIntegerValue BERPDU ::= 5
3761 import from TempA all;
3763 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3768 if (dec_BER_PDU('E1810402810105'O) == myIntegerValue)
3771 {setverdict(pass);} else {setverdict(fail);}
3776 Overall verdict: pass
3782 .*---------------------------------------------------------------------*
3783 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5),Indefinite form,CER
3784 .*---------------------------------------------------------------------*
3787 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5),Indefinite form,CER>
3795 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
3797 myIntegerValue BERPDU ::= 5
3803 import from TempA all;
3805 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3810 if (dec_BER_PDU('E1800201050000'O) == myIntegerValue)
3813 {setverdict(pass);} else {setverdict(fail);}
3818 Overall verdict: pass
3824 .*---------------------------------------------------------------------*
3825 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Short form - Short form, DER
3826 .*---------------------------------------------------------------------*
3829 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Short form - Short form, DER>
3837 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
3839 myIntegerValue BERPDU ::= 5
3845 import from TempA all;
3847 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3852 if (dec_BER_PDU('6203020105'O) == myIntegerValue)
3855 {setverdict(pass);} else {setverdict(fail);}
3860 Overall verdict: pass
3866 .*---------------------------------------------------------------------*
3867 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Short form - long form
3868 .*---------------------------------------------------------------------*
3871 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Short form - long form>
3879 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
3881 myIntegerValue BERPDU ::= 5
3887 import from TempA all;
3889 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3894 if (dec_BER_PDU('620402810105'O) == myIntegerValue)
3897 {setverdict(pass);} else {setverdict(fail);}
3902 Overall verdict: pass
3908 .*---------------------------------------------------------------------*
3909 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Long form - short form
3910 .*---------------------------------------------------------------------*
3913 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Long form - short form>
3921 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
3923 myIntegerValue BERPDU ::= 5
3929 import from TempA all;
3931 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3936 if (dec_BER_PDU('628103020105'O) == myIntegerValue)
3939 {setverdict(pass);} else {setverdict(fail);}
3944 Overall verdict: pass
3950 .*---------------------------------------------------------------------*
3951 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Long form Long form
3952 .*---------------------------------------------------------------------*
3955 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Long form Long form>
3963 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
3965 myIntegerValue BERPDU ::= 5
3971 import from TempA all;
3973 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3978 if (dec_BER_PDU('62810402810105'O) == myIntegerValue)
3981 {setverdict(pass);} else {setverdict(fail);}
3986 Overall verdict: pass
3992 .*---------------------------------------------------------------------*
3993 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5),Indefinite form,CER
3994 .*---------------------------------------------------------------------*
3997 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5),Indefinite form,CER>
4005 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
4007 myIntegerValue BERPDU ::= 5
4013 import from TempA all;
4015 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4020 if (dec_BER_PDU('62800201050000'O) == myIntegerValue)
4023 {setverdict(pass);} else {setverdict(fail);}
4028 Overall verdict: pass
4034 .*---------------------------------------------------------------------*
4035 :h3. DECODING [0] IMPLICIT INTEGER (5),Short form CER,DER
4036 .*---------------------------------------------------------------------*
4039 <TC - DECODING [0] IMPLICIT INTEGER (5),Short form CER,DER>
4047 BERPDU ::= [0] IMPLICIT INTEGER
4049 myIntegerValue BERPDU ::= 5
4055 import from TempA all;
4057 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4062 if (dec_BER_PDU('800105'O) == myIntegerValue)
4065 {setverdict(pass);} else {setverdict(fail);}
4070 Overall verdict: pass
4076 .*---------------------------------------------------------------------*
4077 :h3. DECODING [0] IMPLICIT INTEGER (5),Long form
4078 .*---------------------------------------------------------------------*
4081 <TC - DECODING [0] IMPLICIT INTEGER (5),Long form>
4089 BERPDU ::= [0] IMPLICIT INTEGER
4091 myIntegerValue BERPDU ::= 5
4097 import from TempA all;
4099 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4104 if (dec_BER_PDU('80810105'O) == myIntegerValue)
4107 {setverdict(pass);} else {setverdict(fail);}
4112 Overall verdict: pass
4118 .*---------------------------------------------------------------------*
4119 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (5),Short form CER,DER
4120 .*---------------------------------------------------------------------*
4123 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (5),Short form CER,DER>
4131 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
4133 myIntegerValue BERPDU ::= 5
4139 import from TempA all;
4141 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4146 if (dec_BER_PDU('C10105'O) == myIntegerValue)
4149 {setverdict(pass);} else {setverdict(fail);}
4154 Overall verdict: pass
4160 .*---------------------------------------------------------------------*
4161 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (5),Long form
4162 .*---------------------------------------------------------------------*
4165 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (5),Long form>
4173 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
4175 myIntegerValue BERPDU ::= 5
4181 import from TempA all;
4183 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4188 if (dec_BER_PDU('C1810105'O) == myIntegerValue)
4191 {setverdict(pass);} else {setverdict(fail);}
4196 Overall verdict: pass
4202 .*---------------------------------------------------------------------*
4203 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (5),Short form CER,DER
4204 .*---------------------------------------------------------------------*
4207 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (5),Short form CER,DER>
4215 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
4217 myIntegerValue BERPDU ::= 5
4223 import from TempA all;
4225 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4230 if (dec_BER_PDU('420105'O) == myIntegerValue)
4233 {setverdict(pass);} else {setverdict(fail);}
4238 Overall verdict: pass
4244 .*---------------------------------------------------------------------*
4245 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (5),Long form
4246 .*---------------------------------------------------------------------*
4249 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (5),Long form>
4257 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
4259 myIntegerValue BERPDU ::= 5
4265 import from TempA all;
4267 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4272 if (dec_BER_PDU('42810105'O) == myIntegerValue)
4275 {setverdict(pass);} else {setverdict(fail);}
4280 Overall verdict: pass
4286 .*---------------------------------------------------------------------*
4287 :h3. DECODING INTEGER (0), CER+DER
4288 .*---------------------------------------------------------------------*
4291 <TC - DECODING INTEGER (0), CER+DER>
4301 myIntegerValue BERPDU ::= 0
4307 import from TempA all;
4309 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4314 if (dec_BER_PDU('020100'O) == myIntegerValue)
4317 {setverdict(pass);} else {setverdict(fail);}
4322 Overall verdict: pass
4328 .*---------------------------------------------------------------------*
4329 :h3. DECODING INTEGER (0), (LENGTH OF LENGTH = 1)
4330 .*---------------------------------------------------------------------*
4333 <TC - DECODING INTEGER (0), (LENGTH OF LENGTH = 1)>
4343 myIntegerValue BERPDU ::= 0
4349 import from TempA all;
4351 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4356 if (dec_BER_PDU('02810100'O) == myIntegerValue)
4359 {setverdict(pass);} else {setverdict(fail);}
4364 Overall verdict: pass
4370 .*---------------------------------------------------------------------*
4371 :h3. DECODING INTEGER (0), (LENGTH OF LENGTH = 2)
4372 .*---------------------------------------------------------------------*
4375 <TC - DECODING INTEGER (0), (LENGTH OF LENGTH = 2)>
4385 myIntegerValue BERPDU ::= 0
4391 import from TempA all;
4393 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4398 if (dec_BER_PDU('0282000100'O) == myIntegerValue)
4401 {setverdict(pass);} else {setverdict(fail);}
4406 Overall verdict: pass
4412 .*---------------------------------------------------------------------*
4413 :h3. DECODING [0] EXPLICIT INTEGER (0), DER
4414 .*---------------------------------------------------------------------*
4417 <TC - DECODING [0] EXPLICIT INTEGER (0), DER>
4425 BERPDU ::= [0] EXPLICIT INTEGER
4427 myIntegerValue BERPDU ::= 0
4433 import from TempA all;
4435 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4440 if (dec_BER_PDU('A003020100'O) == myIntegerValue)
4443 {setverdict(pass);} else {setverdict(fail);}
4448 Overall verdict: pass
4454 .*---------------------------------------------------------------------*
4455 :h3. DECODING [0] EXPLICIT INTEGER (0), CER
4456 .*---------------------------------------------------------------------*
4459 <TC - DECODING [0] EXPLICIT INTEGER (0), CER>
4467 BERPDU ::= [0] EXPLICIT INTEGER
4469 myIntegerValue BERPDU ::= 0
4475 import from TempA all;
4477 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4482 if (dec_BER_PDU('A0800201000000'O) == myIntegerValue)
4485 {setverdict(pass);} else {setverdict(fail);}
4490 Overall verdict: pass
4496 .*---------------------------------------------------------------------*
4497 :h3. DECODING [0] EXPLICIT INTEGER (0), Short form - long form
4498 .*---------------------------------------------------------------------*
4501 <TC - DECODING [0] EXPLICIT INTEGER (0), Short form - long form>
4509 BERPDU ::= [0] EXPLICIT INTEGER
4511 myIntegerValue BERPDU ::= 0
4517 import from TempA all;
4519 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4524 if (dec_BER_PDU('A003020100'O) == myIntegerValue)
4527 {setverdict(pass);} else {setverdict(fail);}
4532 Overall verdict: pass
4538 .*---------------------------------------------------------------------*
4539 :h3. DECODING [0] EXPLICIT INTEGER (0), Long form - short form
4540 .*---------------------------------------------------------------------*
4543 <TC - DECODING [0] EXPLICIT INTEGER (0), Long form - short form>
4551 BERPDU ::= [0] EXPLICIT INTEGER
4553 myIntegerValue BERPDU ::= 0
4559 import from TempA all;
4561 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4566 if (dec_BER_PDU('A08103020100'O) == myIntegerValue)
4569 {setverdict(pass);} else {setverdict(fail);}
4574 Overall verdict: pass
4580 .*---------------------------------------------------------------------*
4581 :h3. DECODING [0] EXPLICIT INTEGER (0), Long form Long form
4582 .*---------------------------------------------------------------------*
4585 <TC - DECODING [0] EXPLICIT INTEGER (0), Long form Long form>
4593 BERPDU ::= [0] EXPLICIT INTEGER
4595 myIntegerValue BERPDU ::= 0
4601 import from TempA all;
4603 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4608 if (dec_BER_PDU('A0810402810100'O) == myIntegerValue)
4611 {setverdict(pass);} else {setverdict(fail);}
4616 Overall verdict: pass
4622 .*---------------------------------------------------------------------*
4623 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Short form - Short form, DER
4624 .*---------------------------------------------------------------------*
4627 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Short form - Short form, DER>
4635 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
4637 myIntegerValue BERPDU ::= 0
4643 import from TempA all;
4645 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4650 if (dec_BER_PDU('E103020100'O) == myIntegerValue)
4653 {setverdict(pass);} else {setverdict(fail);}
4658 Overall verdict: pass
4664 .*---------------------------------------------------------------------*
4665 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Short form - long form
4666 .*---------------------------------------------------------------------*
4669 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Short form - long form>
4677 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
4679 myIntegerValue BERPDU ::= 0
4685 import from TempA all;
4687 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4692 if (dec_BER_PDU('E10402810100'O) == myIntegerValue)
4695 {setverdict(pass);} else {setverdict(fail);}
4700 Overall verdict: pass
4706 .*---------------------------------------------------------------------*
4707 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Long form - short form
4708 .*---------------------------------------------------------------------*
4711 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Long form - short form>
4719 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
4721 myIntegerValue BERPDU ::= 0
4727 import from TempA all;
4729 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4734 if (dec_BER_PDU('E18103020100'O) == myIntegerValue)
4737 {setverdict(pass);} else {setverdict(fail);}
4742 Overall verdict: pass
4748 .*---------------------------------------------------------------------*
4749 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Long form Long form
4750 .*---------------------------------------------------------------------*
4753 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Long form Long form>
4761 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
4763 myIntegerValue BERPDU ::= 0
4769 import from TempA all;
4771 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4776 if (dec_BER_PDU('E1810402810100'O) == myIntegerValue)
4779 {setverdict(pass);} else {setverdict(fail);}
4784 Overall verdict: pass
4790 .*---------------------------------------------------------------------*
4791 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0),Indefinite form,CER
4792 .*---------------------------------------------------------------------*
4795 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0),Indefinite form,CER>
4803 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
4805 myIntegerValue BERPDU ::= 0
4811 import from TempA all;
4813 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4818 if (dec_BER_PDU('E1800201000000'O) == myIntegerValue)
4821 {setverdict(pass);} else {setverdict(fail);}
4826 Overall verdict: pass
4832 .*---------------------------------------------------------------------*
4833 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Short form - Short form, DER
4834 .*---------------------------------------------------------------------*
4837 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Short form - Short form, DER>
4845 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
4847 myIntegerValue BERPDU ::= 0
4853 import from TempA all;
4855 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4860 if (dec_BER_PDU('6203020100'O) == myIntegerValue)
4863 {setverdict(pass);} else {setverdict(fail);}
4868 Overall verdict: pass
4874 .*---------------------------------------------------------------------*
4875 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Short form - long form
4876 .*---------------------------------------------------------------------*
4879 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Short form - long form>
4887 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
4889 myIntegerValue BERPDU ::= 0
4895 import from TempA all;
4897 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4902 if (dec_BER_PDU('620402810100'O) == myIntegerValue)
4905 {setverdict(pass);} else {setverdict(fail);}
4910 Overall verdict: pass
4916 .*---------------------------------------------------------------------*
4917 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Long form - short form
4918 .*---------------------------------------------------------------------*
4921 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Long form - short form>
4929 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
4931 myIntegerValue BERPDU ::= 0
4937 import from TempA all;
4939 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4944 if (dec_BER_PDU('628103020100'O) == myIntegerValue)
4947 {setverdict(pass);} else {setverdict(fail);}
4952 Overall verdict: pass
4958 .*---------------------------------------------------------------------*
4959 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Long form Long form
4960 .*---------------------------------------------------------------------*
4963 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Long form Long form>
4971 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
4973 myIntegerValue BERPDU ::= 0
4979 import from TempA all;
4981 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4986 if (dec_BER_PDU('62810402810100'O) == myIntegerValue)
4989 {setverdict(pass);} else {setverdict(fail);}
4994 Overall verdict: pass
5000 .*---------------------------------------------------------------------*
5001 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0),Indefinite form,CER
5002 .*---------------------------------------------------------------------*
5005 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0),Indefinite form,CER>
5013 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
5015 myIntegerValue BERPDU ::= 0
5021 import from TempA all;
5023 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5028 if (dec_BER_PDU('62800201000000'O) == myIntegerValue)
5031 {setverdict(pass);} else {setverdict(fail);}
5036 Overall verdict: pass
5042 .*---------------------------------------------------------------------*
5043 :h3. DECODING [0] IMPLICIT INTEGER (0),Short form CER,DER
5044 .*---------------------------------------------------------------------*
5047 <TC - DECODING [0] IMPLICIT INTEGER (0),Short form CER,DER>
5055 BERPDU ::= [0] IMPLICIT INTEGER
5057 myIntegerValue BERPDU ::= 0
5063 import from TempA all;
5065 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5070 if (dec_BER_PDU('800100'O) == myIntegerValue)
5073 {setverdict(pass);} else {setverdict(fail);}
5078 Overall verdict: pass
5084 .*---------------------------------------------------------------------*
5085 :h3. DECODING [0] IMPLICIT INTEGER (0),Long form
5086 .*---------------------------------------------------------------------*
5089 <TC - DECODING [0] IMPLICIT INTEGER (0),Long form>
5097 BERPDU ::= [0] IMPLICIT INTEGER
5099 myIntegerValue BERPDU ::= 0
5105 import from TempA all;
5107 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5112 if (dec_BER_PDU('80810100'O) == myIntegerValue)
5115 {setverdict(pass);} else {setverdict(fail);}
5120 Overall verdict: pass
5126 .*---------------------------------------------------------------------*
5127 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (0),Short form CER,DER
5128 .*---------------------------------------------------------------------*
5131 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (0),Short form CER,DER>
5139 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
5141 myIntegerValue BERPDU ::= 0
5147 import from TempA all;
5149 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5154 if (dec_BER_PDU('C10100'O) == myIntegerValue)
5157 {setverdict(pass);} else {setverdict(fail);}
5162 Overall verdict: pass
5168 .*---------------------------------------------------------------------*
5169 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (0),Long form
5170 .*---------------------------------------------------------------------*
5173 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (0),Long form>
5181 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
5183 myIntegerValue BERPDU ::= 0
5189 import from TempA all;
5191 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5196 if (dec_BER_PDU('C1810100'O) == myIntegerValue)
5199 {setverdict(pass);} else {setverdict(fail);}
5204 Overall verdict: pass
5210 .*---------------------------------------------------------------------*
5211 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (0),Short form CER,DER
5212 .*---------------------------------------------------------------------*
5215 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (0),Short form CER,DER>
5223 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
5225 myIntegerValue BERPDU ::= 0
5231 import from TempA all;
5233 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5238 if (dec_BER_PDU('420100'O) == myIntegerValue)
5241 {setverdict(pass);} else {setverdict(fail);}
5246 Overall verdict: pass
5252 .*---------------------------------------------------------------------*
5253 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (0),Long form
5254 .*---------------------------------------------------------------------*
5257 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (0),Long form>
5265 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
5267 myIntegerValue BERPDU ::= 0
5273 import from TempA all;
5275 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5280 if (dec_BER_PDU('42810100'O) == myIntegerValue)
5283 {setverdict(pass);} else {setverdict(fail);}
5288 Overall verdict: pass
5294 .*---------------------------------------------------------------------*
5295 :h3. DECODING INTEGER (127), CER+DER
5296 .*---------------------------------------------------------------------*
5299 <TC - DECODING INTEGER (127), CER+DER>
5309 myIntegerValue BERPDU ::= 127
5315 import from TempA all;
5317 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5322 if (dec_BER_PDU('02017F'O) == myIntegerValue)
5325 {setverdict(pass);} else {setverdict(fail);}
5330 Overall verdict: pass
5336 .*---------------------------------------------------------------------*
5337 :h3. DECODING INTEGER (127), (LENGTH OF LENGTH = 1)
5338 .*---------------------------------------------------------------------*
5341 <TC - DECODING INTEGER (127), (LENGTH OF LENGTH = 1)>
5351 myIntegerValue BERPDU ::= 127
5357 import from TempA all;
5359 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5364 if (dec_BER_PDU('0281017F'O) == myIntegerValue)
5367 {setverdict(pass);} else {setverdict(fail);}
5372 Overall verdict: pass
5378 .*---------------------------------------------------------------------*
5379 :h3. DECODING INTEGER (127), (LENGTH OF LENGTH = 2)
5380 .*---------------------------------------------------------------------*
5383 <TC - DECODING INTEGER (127), (LENGTH OF LENGTH = 2)>
5393 myIntegerValue BERPDU ::= 127
5399 import from TempA all;
5401 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5406 if (dec_BER_PDU('028200017F'O) == myIntegerValue)
5409 {setverdict(pass);} else {setverdict(fail);}
5414 Overall verdict: pass
5420 .*---------------------------------------------------------------------*
5421 :h3. DECODING [0] EXPLICIT INTEGER (127), DER
5422 .*---------------------------------------------------------------------*
5425 <TC - DECODING [0] EXPLICIT INTEGER (127), DER>
5433 BERPDU ::= [0] EXPLICIT INTEGER
5435 myIntegerValue BERPDU ::= 127
5441 import from TempA all;
5443 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5448 if (dec_BER_PDU('A00302017F'O) == myIntegerValue)
5451 {setverdict(pass);} else {setverdict(fail);}
5456 Overall verdict: pass
5462 .*---------------------------------------------------------------------*
5463 :h3. DECODING [0] EXPLICIT INTEGER (127), CER
5464 .*---------------------------------------------------------------------*
5467 <TC - DECODING [0] EXPLICIT INTEGER (127), CER>
5475 BERPDU ::= [0] EXPLICIT INTEGER
5477 myIntegerValue BERPDU ::= 127
5483 import from TempA all;
5485 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5490 if (dec_BER_PDU('A08002017F0000'O) == myIntegerValue)
5493 {setverdict(pass);} else {setverdict(fail);}
5498 Overall verdict: pass
5504 .*---------------------------------------------------------------------*
5505 :h3. DECODING [0] EXPLICIT INTEGER (127), Short form - long form
5506 .*---------------------------------------------------------------------*
5509 <TC - DECODING [0] EXPLICIT INTEGER (127), Short form - long form>
5517 BERPDU ::= [0] EXPLICIT INTEGER
5519 myIntegerValue BERPDU ::= 127
5525 import from TempA all;
5527 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5532 if (dec_BER_PDU('A00302017F'O) == myIntegerValue)
5535 {setverdict(pass);} else {setverdict(fail);}
5540 Overall verdict: pass
5546 .*---------------------------------------------------------------------*
5547 :h3. DECODING [0] EXPLICIT INTEGER (127), Long form - short form
5548 .*---------------------------------------------------------------------*
5551 <TC - DECODING [0] EXPLICIT INTEGER (127), Long form - short form>
5559 BERPDU ::= [0] EXPLICIT INTEGER
5561 myIntegerValue BERPDU ::= 127
5567 import from TempA all;
5569 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5574 if (dec_BER_PDU('A0810302017F'O) == myIntegerValue)
5577 {setverdict(pass);} else {setverdict(fail);}
5582 Overall verdict: pass
5588 .*---------------------------------------------------------------------*
5589 :h3. DECODING [0] EXPLICIT INTEGER (127), Long form Long form
5590 .*---------------------------------------------------------------------*
5593 <TC - DECODING [0] EXPLICIT INTEGER (127), Long form Long form>
5601 BERPDU ::= [0] EXPLICIT INTEGER
5603 myIntegerValue BERPDU ::= 127
5609 import from TempA all;
5611 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5616 if (dec_BER_PDU('A081040281017F'O) == myIntegerValue)
5619 {setverdict(pass);} else {setverdict(fail);}
5624 Overall verdict: pass
5630 .*---------------------------------------------------------------------*
5631 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Short form - Short form, DER
5632 .*---------------------------------------------------------------------*
5635 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Short form - Short form, DER>
5643 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
5645 myIntegerValue BERPDU ::= 127
5651 import from TempA all;
5653 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5658 if (dec_BER_PDU('E10302017F'O) == myIntegerValue)
5661 {setverdict(pass);} else {setverdict(fail);}
5666 Overall verdict: pass
5672 .*---------------------------------------------------------------------*
5673 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Short form - long form
5674 .*---------------------------------------------------------------------*
5677 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Short form - long form>
5685 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
5687 myIntegerValue BERPDU ::= 127
5693 import from TempA all;
5695 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5700 if (dec_BER_PDU('E1040281017F'O) == myIntegerValue)
5703 {setverdict(pass);} else {setverdict(fail);}
5708 Overall verdict: pass
5714 .*---------------------------------------------------------------------*
5715 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Long form - short form
5716 .*---------------------------------------------------------------------*
5719 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Long form - short form>
5727 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
5729 myIntegerValue BERPDU ::= 127
5735 import from TempA all;
5737 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5742 if (dec_BER_PDU('E1810302017F'O) == myIntegerValue)
5745 {setverdict(pass);} else {setverdict(fail);}
5750 Overall verdict: pass
5756 .*---------------------------------------------------------------------*
5757 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Long form Long form
5758 .*---------------------------------------------------------------------*
5761 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Long form Long form>
5769 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
5771 myIntegerValue BERPDU ::= 127
5777 import from TempA all;
5779 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5784 if (dec_BER_PDU('E181040281017F'O) == myIntegerValue)
5787 {setverdict(pass);} else {setverdict(fail);}
5792 Overall verdict: pass
5798 .*---------------------------------------------------------------------*
5799 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127),Indefinite form,CER
5800 .*---------------------------------------------------------------------*
5803 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127),Indefinite form,CER>
5811 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
5813 myIntegerValue BERPDU ::= 127
5819 import from TempA all;
5821 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5826 if (dec_BER_PDU('E18002017F0000'O) == myIntegerValue)
5829 {setverdict(pass);} else {setverdict(fail);}
5834 Overall verdict: pass
5840 .*---------------------------------------------------------------------*
5841 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Short form - Short form, DER
5842 .*---------------------------------------------------------------------*
5845 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Short form - Short form, DER>
5853 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
5855 myIntegerValue BERPDU ::= 127
5861 import from TempA all;
5863 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5868 if (dec_BER_PDU('620302017F'O) == myIntegerValue)
5871 {setverdict(pass);} else {setverdict(fail);}
5876 Overall verdict: pass
5882 .*---------------------------------------------------------------------*
5883 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Short form - long form
5884 .*---------------------------------------------------------------------*
5887 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Short form - long form>
5895 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
5897 myIntegerValue BERPDU ::= 127
5903 import from TempA all;
5905 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5910 if (dec_BER_PDU('62040281017F'O) == myIntegerValue)
5913 {setverdict(pass);} else {setverdict(fail);}
5918 Overall verdict: pass
5924 .*---------------------------------------------------------------------*
5925 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Long form - short form
5926 .*---------------------------------------------------------------------*
5929 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Long form - short form>
5937 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
5939 myIntegerValue BERPDU ::= 127
5945 import from TempA all;
5947 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5952 if (dec_BER_PDU('62810302017F'O) == myIntegerValue)
5955 {setverdict(pass);} else {setverdict(fail);}
5960 Overall verdict: pass
5966 .*---------------------------------------------------------------------*
5967 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Long form Long form
5968 .*---------------------------------------------------------------------*
5971 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Long form Long form>
5979 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
5981 myIntegerValue BERPDU ::= 127
5987 import from TempA all;
5989 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5994 if (dec_BER_PDU('6281040281017F'O) == myIntegerValue)
5997 {setverdict(pass);} else {setverdict(fail);}
6002 Overall verdict: pass
6008 .*---------------------------------------------------------------------*
6009 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127),Indefinite form,CER
6010 .*---------------------------------------------------------------------*
6013 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127),Indefinite form,CER>
6021 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
6023 myIntegerValue BERPDU ::= 127
6029 import from TempA all;
6031 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6036 if (dec_BER_PDU('628002017F0000'O) == myIntegerValue)
6039 {setverdict(pass);} else {setverdict(fail);}
6044 Overall verdict: pass
6050 .*---------------------------------------------------------------------*
6051 :h3. DECODING [0] IMPLICIT INTEGER (127),Short form CER,DER
6052 .*---------------------------------------------------------------------*
6055 <TC - DECODING [0] IMPLICIT INTEGER (127),Short form CER,DER>
6063 BERPDU ::= [0] IMPLICIT INTEGER
6065 myIntegerValue BERPDU ::= 127
6071 import from TempA all;
6073 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6078 if (dec_BER_PDU('80017F'O) == myIntegerValue)
6081 {setverdict(pass);} else {setverdict(fail);}
6086 Overall verdict: pass
6092 .*---------------------------------------------------------------------*
6093 :h3. DECODING [0] IMPLICIT INTEGER (127),Long form
6094 .*---------------------------------------------------------------------*
6097 <TC - DECODING [0] IMPLICIT INTEGER (127),Long form>
6105 BERPDU ::= [0] IMPLICIT INTEGER
6107 myIntegerValue BERPDU ::= 127
6113 import from TempA all;
6115 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6120 if (dec_BER_PDU('8081017F'O) == myIntegerValue)
6123 {setverdict(pass);} else {setverdict(fail);}
6128 Overall verdict: pass
6134 .*---------------------------------------------------------------------*
6135 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (127),Short form CER,DER
6136 .*---------------------------------------------------------------------*
6139 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (127),Short form CER,DER>
6147 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
6149 myIntegerValue BERPDU ::= 127
6155 import from TempA all;
6157 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6162 if (dec_BER_PDU('C1017F'O) == myIntegerValue)
6165 {setverdict(pass);} else {setverdict(fail);}
6170 Overall verdict: pass
6176 .*---------------------------------------------------------------------*
6177 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (127),Long form
6178 .*---------------------------------------------------------------------*
6181 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (127),Long form>
6189 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
6191 myIntegerValue BERPDU ::= 127
6197 import from TempA all;
6199 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6204 if (dec_BER_PDU('C181017F'O) == myIntegerValue)
6207 {setverdict(pass);} else {setverdict(fail);}
6212 Overall verdict: pass
6218 .*---------------------------------------------------------------------*
6219 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (127),Short form CER,DER
6220 .*---------------------------------------------------------------------*
6223 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (127),Short form CER,DER>
6231 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
6233 myIntegerValue BERPDU ::= 127
6239 import from TempA all;
6241 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6246 if (dec_BER_PDU('42017F'O) == myIntegerValue)
6249 {setverdict(pass);} else {setverdict(fail);}
6254 Overall verdict: pass
6260 .*---------------------------------------------------------------------*
6261 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (127),Long form
6262 .*---------------------------------------------------------------------*
6265 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (127),Long form>
6273 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
6275 myIntegerValue BERPDU ::= 127
6281 import from TempA all;
6283 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6288 if (dec_BER_PDU('4281017F'O) == myIntegerValue)
6291 {setverdict(pass);} else {setverdict(fail);}
6296 Overall verdict: pass
6302 .*---------------------------------------------------------------------*
6303 :h3. DECODING INTEGER (-128), CER+DER
6304 .*---------------------------------------------------------------------*
6307 <TC - DECODING INTEGER (-128), CER+DER>
6317 myIntegerValue BERPDU ::= -128
6323 import from TempA all;
6325 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6330 if (dec_BER_PDU('020180'O) == myIntegerValue)
6333 {setverdict(pass);} else {setverdict(fail);}
6338 Overall verdict: pass
6344 .*---------------------------------------------------------------------*
6345 :h3. DECODING INTEGER (-128), (LENGTH OF LENGTH = 1)
6346 .*---------------------------------------------------------------------*
6349 <TC - DECODING INTEGER (-128), (LENGTH OF LENGTH = 1)>
6359 myIntegerValue BERPDU ::= -128
6365 import from TempA all;
6367 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6372 if (dec_BER_PDU('02810180'O) == myIntegerValue)
6375 {setverdict(pass);} else {setverdict(fail);}
6380 Overall verdict: pass
6386 .*---------------------------------------------------------------------*
6387 :h3. DECODING INTEGER (-128), (LENGTH OF LENGTH = 2)
6388 .*---------------------------------------------------------------------*
6391 <TC - DECODING INTEGER (-128), (LENGTH OF LENGTH = 2)>
6401 myIntegerValue BERPDU ::= -128
6407 import from TempA all;
6409 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6414 if (dec_BER_PDU('0282000180'O) == myIntegerValue)
6417 {setverdict(pass);} else {setverdict(fail);}
6422 Overall verdict: pass
6428 .*---------------------------------------------------------------------*
6429 :h3. DECODING [0] EXPLICIT INTEGER (-128), DER
6430 .*---------------------------------------------------------------------*
6433 <TC - DECODING [0] EXPLICIT INTEGER (-128), DER>
6441 BERPDU ::= [0] EXPLICIT INTEGER
6443 myIntegerValue BERPDU ::= -128
6449 import from TempA all;
6451 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6456 if (dec_BER_PDU('A003020180'O) == myIntegerValue)
6459 {setverdict(pass);} else {setverdict(fail);}
6464 Overall verdict: pass
6470 .*---------------------------------------------------------------------*
6471 :h3. DECODING [0] EXPLICIT INTEGER (-128), CER
6472 .*---------------------------------------------------------------------*
6475 <TC - DECODING [0] EXPLICIT INTEGER (-128), CER>
6483 BERPDU ::= [0] EXPLICIT INTEGER
6485 myIntegerValue BERPDU ::= -128
6491 import from TempA all;
6493 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6498 if (dec_BER_PDU('A0800201800000'O) == myIntegerValue)
6501 {setverdict(pass);} else {setverdict(fail);}
6506 Overall verdict: pass
6512 .*---------------------------------------------------------------------*
6513 :h3. DECODING [0] EXPLICIT INTEGER (-128), Short form - long form
6514 .*---------------------------------------------------------------------*
6517 <TC - DECODING [0] EXPLICIT INTEGER (-128), Short form - long form>
6525 BERPDU ::= [0] EXPLICIT INTEGER
6527 myIntegerValue BERPDU ::= -128
6533 import from TempA all;
6535 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6540 if (dec_BER_PDU('A003020180'O) == myIntegerValue)
6543 {setverdict(pass);} else {setverdict(fail);}
6548 Overall verdict: pass
6554 .*---------------------------------------------------------------------*
6555 :h3. DECODING [0] EXPLICIT INTEGER (-128), Long form - short form
6556 .*---------------------------------------------------------------------*
6559 <TC - DECODING [0] EXPLICIT INTEGER (-128), Long form - short form>
6567 BERPDU ::= [0] EXPLICIT INTEGER
6569 myIntegerValue BERPDU ::= -128
6575 import from TempA all;
6577 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6582 if (dec_BER_PDU('A08103020180'O) == myIntegerValue)
6585 {setverdict(pass);} else {setverdict(fail);}
6590 Overall verdict: pass
6596 .*---------------------------------------------------------------------*
6597 :h3. DECODING [0] EXPLICIT INTEGER (-128), Long form Long form
6598 .*---------------------------------------------------------------------*
6601 <TC - DECODING [0] EXPLICIT INTEGER (-128), Long form Long form>
6609 BERPDU ::= [0] EXPLICIT INTEGER
6611 myIntegerValue BERPDU ::= -128
6617 import from TempA all;
6619 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6624 if (dec_BER_PDU('A0810402810180'O) == myIntegerValue)
6627 {setverdict(pass);} else {setverdict(fail);}
6632 Overall verdict: pass
6638 .*---------------------------------------------------------------------*
6639 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Short form - Short form, DER
6640 .*---------------------------------------------------------------------*
6643 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Short form - Short form, DER>
6651 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
6653 myIntegerValue BERPDU ::= -128
6659 import from TempA all;
6661 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6666 if (dec_BER_PDU('E103020180'O) == myIntegerValue)
6669 {setverdict(pass);} else {setverdict(fail);}
6674 Overall verdict: pass
6680 .*---------------------------------------------------------------------*
6681 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Short form - long form
6682 .*---------------------------------------------------------------------*
6685 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Short form - long form>
6693 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
6695 myIntegerValue BERPDU ::= -128
6701 import from TempA all;
6703 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6708 if (dec_BER_PDU('E10402810180'O) == myIntegerValue)
6711 {setverdict(pass);} else {setverdict(fail);}
6716 Overall verdict: pass
6722 .*---------------------------------------------------------------------*
6723 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Long form - short form
6724 .*---------------------------------------------------------------------*
6727 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Long form - short form>
6735 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
6737 myIntegerValue BERPDU ::= -128
6743 import from TempA all;
6745 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6750 if (dec_BER_PDU('E18103020180'O) == myIntegerValue)
6753 {setverdict(pass);} else {setverdict(fail);}
6758 Overall verdict: pass
6764 .*---------------------------------------------------------------------*
6765 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Long form Long form
6766 .*---------------------------------------------------------------------*
6769 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Long form Long form>
6777 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
6779 myIntegerValue BERPDU ::= -128
6785 import from TempA all;
6787 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6792 if (dec_BER_PDU('E1810402810180'O) == myIntegerValue)
6795 {setverdict(pass);} else {setverdict(fail);}
6800 Overall verdict: pass
6806 .*---------------------------------------------------------------------*
6807 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128),Indefinite form,CER
6808 .*---------------------------------------------------------------------*
6811 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128),Indefinite form,CER>
6819 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
6821 myIntegerValue BERPDU ::= -128
6827 import from TempA all;
6829 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6834 if (dec_BER_PDU('E1800201800000'O) == myIntegerValue)
6837 {setverdict(pass);} else {setverdict(fail);}
6842 Overall verdict: pass
6848 .*---------------------------------------------------------------------*
6849 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Short form - Short form, DER
6850 .*---------------------------------------------------------------------*
6853 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Short form - Short form, DER>
6861 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
6863 myIntegerValue BERPDU ::= -128
6869 import from TempA all;
6871 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6876 if (dec_BER_PDU('6203020180'O) == myIntegerValue)
6879 {setverdict(pass);} else {setverdict(fail);}
6884 Overall verdict: pass
6890 .*---------------------------------------------------------------------*
6891 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Short form - long form
6892 .*---------------------------------------------------------------------*
6895 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Short form - long form>
6903 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
6905 myIntegerValue BERPDU ::= -128
6911 import from TempA all;
6913 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6918 if (dec_BER_PDU('620402810180'O) == myIntegerValue)
6921 {setverdict(pass);} else {setverdict(fail);}
6926 Overall verdict: pass
6932 .*---------------------------------------------------------------------*
6933 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Long form - short form
6934 .*---------------------------------------------------------------------*
6937 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Long form - short form>
6945 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
6947 myIntegerValue BERPDU ::= -128
6953 import from TempA all;
6955 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6960 if (dec_BER_PDU('628103020180'O) == myIntegerValue)
6963 {setverdict(pass);} else {setverdict(fail);}
6968 Overall verdict: pass
6974 .*---------------------------------------------------------------------*
6975 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Long form Long form
6976 .*---------------------------------------------------------------------*
6979 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Long form Long form>
6987 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
6989 myIntegerValue BERPDU ::= -128
6995 import from TempA all;
6997 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7002 if (dec_BER_PDU('62810402810180'O) == myIntegerValue)
7005 {setverdict(pass);} else {setverdict(fail);}
7010 Overall verdict: pass
7016 .*---------------------------------------------------------------------*
7017 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128),Indefinite form,CER
7018 .*---------------------------------------------------------------------*
7021 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128),Indefinite form,CER>
7029 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
7031 myIntegerValue BERPDU ::= -128
7037 import from TempA all;
7039 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7044 if (dec_BER_PDU('62800201800000'O) == myIntegerValue)
7047 {setverdict(pass);} else {setverdict(fail);}
7052 Overall verdict: pass
7058 .*---------------------------------------------------------------------*
7059 :h3. DECODING [0] IMPLICIT INTEGER (-128),Short form CER,DER
7060 .*---------------------------------------------------------------------*
7063 <TC - DECODING [0] IMPLICIT INTEGER (-128),Short form CER,DER>
7071 BERPDU ::= [0] IMPLICIT INTEGER
7073 myIntegerValue BERPDU ::= -128
7079 import from TempA all;
7081 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7086 if (dec_BER_PDU('800180'O) == myIntegerValue)
7089 {setverdict(pass);} else {setverdict(fail);}
7094 Overall verdict: pass
7100 .*---------------------------------------------------------------------*
7101 :h3. DECODING [0] IMPLICIT INTEGER (-128),Long form
7102 .*---------------------------------------------------------------------*
7105 <TC - DECODING [0] IMPLICIT INTEGER (-128),Long form>
7113 BERPDU ::= [0] IMPLICIT INTEGER
7115 myIntegerValue BERPDU ::= -128
7121 import from TempA all;
7123 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7128 if (dec_BER_PDU('80810180'O) == myIntegerValue)
7131 {setverdict(pass);} else {setverdict(fail);}
7136 Overall verdict: pass
7142 .*---------------------------------------------------------------------*
7143 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-128),Short form CER,DER
7144 .*---------------------------------------------------------------------*
7147 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-128),Short form CER,DER>
7155 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
7157 myIntegerValue BERPDU ::= -128
7163 import from TempA all;
7165 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7170 if (dec_BER_PDU('C10180'O) == myIntegerValue)
7173 {setverdict(pass);} else {setverdict(fail);}
7178 Overall verdict: pass
7184 .*---------------------------------------------------------------------*
7185 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-128),Long form
7186 .*---------------------------------------------------------------------*
7189 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-128),Long form>
7197 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
7199 myIntegerValue BERPDU ::= -128
7205 import from TempA all;
7207 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7212 if (dec_BER_PDU('C1810180'O) == myIntegerValue)
7215 {setverdict(pass);} else {setverdict(fail);}
7220 Overall verdict: pass
7226 .*---------------------------------------------------------------------*
7227 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-128),Short form CER,DER
7228 .*---------------------------------------------------------------------*
7231 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-128),Short form CER,DER>
7239 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
7241 myIntegerValue BERPDU ::= -128
7247 import from TempA all;
7249 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7254 if (dec_BER_PDU('420180'O) == myIntegerValue)
7257 {setverdict(pass);} else {setverdict(fail);}
7262 Overall verdict: pass
7268 .*---------------------------------------------------------------------*
7269 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-128),Long form
7270 .*---------------------------------------------------------------------*
7273 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-128),Long form>
7281 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
7283 myIntegerValue BERPDU ::= -128
7289 import from TempA all;
7291 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7296 if (dec_BER_PDU('42810180'O) == myIntegerValue)
7299 {setverdict(pass);} else {setverdict(fail);}
7304 Overall verdict: pass
7310 .*---------------------------------------------------------------------*
7311 :h3. DECODING INTEGER (-5), CER+DER
7312 .*---------------------------------------------------------------------*
7315 <TC - DECODING INTEGER (-5), CER+DER>
7325 myIntegerValue BERPDU ::= -5
7331 import from TempA all;
7333 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7338 if (dec_BER_PDU('0201FB'O) == myIntegerValue)
7341 {setverdict(pass);} else {setverdict(fail);}
7346 Overall verdict: pass
7352 .*---------------------------------------------------------------------*
7353 :h3. DECODING INTEGER (-5), (LENGTH OF LENGTH = 1)
7354 .*---------------------------------------------------------------------*
7357 <TC - DECODING INTEGER (-5), (LENGTH OF LENGTH = 1)>
7367 myIntegerValue BERPDU ::= -5
7373 import from TempA all;
7375 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7380 if (dec_BER_PDU('028101FB'O) == myIntegerValue)
7383 {setverdict(pass);} else {setverdict(fail);}
7388 Overall verdict: pass
7394 .*---------------------------------------------------------------------*
7395 :h3. DECODING INTEGER (-5), (LENGTH OF LENGTH = 2)
7396 .*---------------------------------------------------------------------*
7399 <TC - DECODING INTEGER (-5), (LENGTH OF LENGTH = 2)>
7409 myIntegerValue BERPDU ::= -5
7415 import from TempA all;
7417 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7422 if (dec_BER_PDU('02820001FB'O) == myIntegerValue)
7425 {setverdict(pass);} else {setverdict(fail);}
7430 Overall verdict: pass
7436 .*---------------------------------------------------------------------*
7437 :h3. DECODING [0] EXPLICIT INTEGER (-5), DER
7438 .*---------------------------------------------------------------------*
7441 <TC - DECODING [0] EXPLICIT INTEGER (-5), DER>
7449 BERPDU ::= [0] EXPLICIT INTEGER
7451 myIntegerValue BERPDU ::= -5
7457 import from TempA all;
7459 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7464 if (dec_BER_PDU('A0030201FB'O) == myIntegerValue)
7467 {setverdict(pass);} else {setverdict(fail);}
7472 Overall verdict: pass
7478 .*---------------------------------------------------------------------*
7479 :h3. DECODING [0] EXPLICIT INTEGER (-5), CER
7480 .*---------------------------------------------------------------------*
7483 <TC - DECODING [0] EXPLICIT INTEGER (-5), CER>
7491 BERPDU ::= [0] EXPLICIT INTEGER
7493 myIntegerValue BERPDU ::= -5
7499 import from TempA all;
7501 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7506 if (dec_BER_PDU('A0800201FB0000'O) == myIntegerValue)
7509 {setverdict(pass);} else {setverdict(fail);}
7514 Overall verdict: pass
7520 .*---------------------------------------------------------------------*
7521 :h3. DECODING [0] EXPLICIT INTEGER (-5), Short form - long form
7522 .*---------------------------------------------------------------------*
7525 <TC - DECODING [0] EXPLICIT INTEGER (-5), Short form - long form>
7533 BERPDU ::= [0] EXPLICIT INTEGER
7535 myIntegerValue BERPDU ::= -5
7541 import from TempA all;
7543 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7548 if (dec_BER_PDU('A0030201FB'O) == myIntegerValue)
7551 {setverdict(pass);} else {setverdict(fail);}
7556 Overall verdict: pass
7562 .*---------------------------------------------------------------------*
7563 :h3. DECODING [0] EXPLICIT INTEGER (-5), Long form - short form
7564 .*---------------------------------------------------------------------*
7567 <TC - DECODING [0] EXPLICIT INTEGER (-5), Long form - short form>
7575 BERPDU ::= [0] EXPLICIT INTEGER
7577 myIntegerValue BERPDU ::= -5
7583 import from TempA all;
7585 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7590 if (dec_BER_PDU('A081030201FB'O) == myIntegerValue)
7593 {setverdict(pass);} else {setverdict(fail);}
7598 Overall verdict: pass
7604 .*---------------------------------------------------------------------*
7605 :h3. DECODING [0] EXPLICIT INTEGER (-5), Long form Long form
7606 .*---------------------------------------------------------------------*
7609 <TC - DECODING [0] EXPLICIT INTEGER (-5), Long form Long form>
7617 BERPDU ::= [0] EXPLICIT INTEGER
7619 myIntegerValue BERPDU ::= -5
7625 import from TempA all;
7627 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7632 if (dec_BER_PDU('A08104028101FB'O) == myIntegerValue)
7635 {setverdict(pass);} else {setverdict(fail);}
7640 Overall verdict: pass
7646 .*---------------------------------------------------------------------*
7647 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Short form - Short form, DER
7648 .*---------------------------------------------------------------------*
7651 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Short form - Short form, DER>
7659 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
7661 myIntegerValue BERPDU ::= -5
7667 import from TempA all;
7669 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7674 if (dec_BER_PDU('E1030201FB'O) == myIntegerValue)
7677 {setverdict(pass);} else {setverdict(fail);}
7682 Overall verdict: pass
7688 .*---------------------------------------------------------------------*
7689 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Short form - long form
7690 .*---------------------------------------------------------------------*
7693 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Short form - long form>
7701 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
7703 myIntegerValue BERPDU ::= -5
7709 import from TempA all;
7711 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7716 if (dec_BER_PDU('E104028101FB'O) == myIntegerValue)
7719 {setverdict(pass);} else {setverdict(fail);}
7724 Overall verdict: pass
7730 .*---------------------------------------------------------------------*
7731 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Long form - short form
7732 .*---------------------------------------------------------------------*
7735 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Long form - short form>
7743 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
7745 myIntegerValue BERPDU ::= -5
7751 import from TempA all;
7753 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7758 if (dec_BER_PDU('E181030201FB'O) == myIntegerValue)
7761 {setverdict(pass);} else {setverdict(fail);}
7766 Overall verdict: pass
7772 .*---------------------------------------------------------------------*
7773 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Long form Long form
7774 .*---------------------------------------------------------------------*
7777 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Long form Long form>
7785 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
7787 myIntegerValue BERPDU ::= -5
7793 import from TempA all;
7795 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7800 if (dec_BER_PDU('E18104028101FB'O) == myIntegerValue)
7803 {setverdict(pass);} else {setverdict(fail);}
7808 Overall verdict: pass
7814 .*---------------------------------------------------------------------*
7815 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5),Indefinite form,CER
7816 .*---------------------------------------------------------------------*
7819 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5),Indefinite form,CER>
7827 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
7829 myIntegerValue BERPDU ::= -5
7835 import from TempA all;
7837 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7842 if (dec_BER_PDU('E1800201FB0000'O) == myIntegerValue)
7845 {setverdict(pass);} else {setverdict(fail);}
7850 Overall verdict: pass
7856 .*---------------------------------------------------------------------*
7857 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Short form - Short form, DER
7858 .*---------------------------------------------------------------------*
7861 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Short form - Short form, DER>
7869 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
7871 myIntegerValue BERPDU ::= -5
7877 import from TempA all;
7879 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7884 if (dec_BER_PDU('62030201FB'O) == myIntegerValue)
7887 {setverdict(pass);} else {setverdict(fail);}
7892 Overall verdict: pass
7898 .*---------------------------------------------------------------------*
7899 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Short form - long form
7900 .*---------------------------------------------------------------------*
7903 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Short form - long form>
7911 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
7913 myIntegerValue BERPDU ::= -5
7919 import from TempA all;
7921 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7926 if (dec_BER_PDU('6204028101FB'O) == myIntegerValue)
7929 {setverdict(pass);} else {setverdict(fail);}
7934 Overall verdict: pass
7940 .*---------------------------------------------------------------------*
7941 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Long form - short form
7942 .*---------------------------------------------------------------------*
7945 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Long form - short form>
7953 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
7955 myIntegerValue BERPDU ::= -5
7961 import from TempA all;
7963 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7968 if (dec_BER_PDU('6281030201FB'O) == myIntegerValue)
7971 {setverdict(pass);} else {setverdict(fail);}
7976 Overall verdict: pass
7982 .*---------------------------------------------------------------------*
7983 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Long form Long form
7984 .*---------------------------------------------------------------------*
7987 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Long form Long form>
7995 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
7997 myIntegerValue BERPDU ::= -5
8003 import from TempA all;
8005 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8010 if (dec_BER_PDU('628104028101FB'O) == myIntegerValue)
8013 {setverdict(pass);} else {setverdict(fail);}
8018 Overall verdict: pass
8024 .*---------------------------------------------------------------------*
8025 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5),Indefinite form,CER
8026 .*---------------------------------------------------------------------*
8029 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5),Indefinite form,CER>
8037 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
8039 myIntegerValue BERPDU ::= -5
8045 import from TempA all;
8047 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8052 if (dec_BER_PDU('62800201FB0000'O) == myIntegerValue)
8055 {setverdict(pass);} else {setverdict(fail);}
8060 Overall verdict: pass
8066 .*---------------------------------------------------------------------*
8067 :h3. DECODING [0] IMPLICIT INTEGER (-5),Short form CER,DER
8068 .*---------------------------------------------------------------------*
8071 <TC - DECODING [0] IMPLICIT INTEGER (-5),Short form CER,DER>
8079 BERPDU ::= [0] IMPLICIT INTEGER
8081 myIntegerValue BERPDU ::= -5
8087 import from TempA all;
8089 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8094 if (dec_BER_PDU('8001FB'O) == myIntegerValue)
8097 {setverdict(pass);} else {setverdict(fail);}
8102 Overall verdict: pass
8108 .*---------------------------------------------------------------------*
8109 :h3. DECODING [0] IMPLICIT INTEGER (-5),Long form
8110 .*---------------------------------------------------------------------*
8113 <TC - DECODING [0] IMPLICIT INTEGER (-5),Long form>
8121 BERPDU ::= [0] IMPLICIT INTEGER
8123 myIntegerValue BERPDU ::= -5
8129 import from TempA all;
8131 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8136 if (dec_BER_PDU('808101FB'O) == myIntegerValue)
8139 {setverdict(pass);} else {setverdict(fail);}
8144 Overall verdict: pass
8150 .*---------------------------------------------------------------------*
8151 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-5),Short form CER,DER
8152 .*---------------------------------------------------------------------*
8155 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-5),Short form CER,DER>
8163 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
8165 myIntegerValue BERPDU ::= -5
8171 import from TempA all;
8173 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8178 if (dec_BER_PDU('C101FB'O) == myIntegerValue)
8181 {setverdict(pass);} else {setverdict(fail);}
8186 Overall verdict: pass
8192 .*---------------------------------------------------------------------*
8193 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-5),Long form
8194 .*---------------------------------------------------------------------*
8197 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-5),Long form>
8205 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
8207 myIntegerValue BERPDU ::= -5
8213 import from TempA all;
8215 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8220 if (dec_BER_PDU('C18101FB'O) == myIntegerValue)
8223 {setverdict(pass);} else {setverdict(fail);}
8228 Overall verdict: pass
8234 .*---------------------------------------------------------------------*
8235 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-5),Short form CER,DER
8236 .*---------------------------------------------------------------------*
8239 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-5),Short form CER,DER>
8247 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
8249 myIntegerValue BERPDU ::= -5
8255 import from TempA all;
8257 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8262 if (dec_BER_PDU('4201FB'O) == myIntegerValue)
8265 {setverdict(pass);} else {setverdict(fail);}
8270 Overall verdict: pass
8276 .*---------------------------------------------------------------------*
8277 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-5),Long form
8278 .*---------------------------------------------------------------------*
8281 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-5),Long form>
8289 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
8291 myIntegerValue BERPDU ::= -5
8297 import from TempA all;
8299 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8304 if (dec_BER_PDU('428101FB'O) == myIntegerValue)
8307 {setverdict(pass);} else {setverdict(fail);}
8312 Overall verdict: pass
8318 .*---------------------------------------------------------------------*
8319 :h3. DECODING INTEGER (128), CER+DER
8320 .*---------------------------------------------------------------------*
8323 <TC - DECODING INTEGER (128), CER+DER>
8333 myIntegerValue BERPDU ::= 128
8339 import from TempA all;
8341 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8346 if (dec_BER_PDU('02020080'O) == myIntegerValue)
8349 {setverdict(pass);} else {setverdict(fail);}
8354 Overall verdict: pass
8360 .*---------------------------------------------------------------------*
8361 :h3. DECODING INTEGER (128), (LENGTH OF LENGTH = 1)
8362 .*---------------------------------------------------------------------*
8365 <TC - DECODING INTEGER (128), (LENGTH OF LENGTH = 1)>
8375 myIntegerValue BERPDU ::= 128
8381 import from TempA all;
8383 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8388 if (dec_BER_PDU('0281020080'O) == myIntegerValue)
8391 {setverdict(pass);} else {setverdict(fail);}
8396 Overall verdict: pass
8402 .*---------------------------------------------------------------------*
8403 :h3. DECODING INTEGER (128), (LENGTH OF LENGTH = 2)
8404 .*---------------------------------------------------------------------*
8407 <TC - DECODING INTEGER (128), (LENGTH OF LENGTH = 2)>
8417 myIntegerValue BERPDU ::= 128
8423 import from TempA all;
8425 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8430 if (dec_BER_PDU('028200020080'O) == myIntegerValue)
8433 {setverdict(pass);} else {setverdict(fail);}
8438 Overall verdict: pass
8444 .*---------------------------------------------------------------------*
8445 :h3. DECODING [0] EXPLICIT INTEGER (128), DER
8446 .*---------------------------------------------------------------------*
8449 <TC - DECODING [0] EXPLICIT INTEGER (128), DER>
8457 BERPDU ::= [0] EXPLICIT INTEGER
8459 myIntegerValue BERPDU ::= 128
8465 import from TempA all;
8467 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8472 if (dec_BER_PDU('A00402020080'O) == myIntegerValue)
8475 {setverdict(pass);} else {setverdict(fail);}
8480 Overall verdict: pass
8486 .*---------------------------------------------------------------------*
8487 :h3. DECODING [0] EXPLICIT INTEGER (128), CER
8488 .*---------------------------------------------------------------------*
8491 <TC - DECODING [0] EXPLICIT INTEGER (128), CER>
8499 BERPDU ::= [0] EXPLICIT INTEGER
8501 myIntegerValue BERPDU ::= 128
8507 import from TempA all;
8509 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8514 if (dec_BER_PDU('A080020200800000'O) == myIntegerValue)
8517 {setverdict(pass);} else {setverdict(fail);}
8522 Overall verdict: pass
8528 .*---------------------------------------------------------------------*
8529 :h3. DECODING [0] EXPLICIT INTEGER (128), Short form - long form
8530 .*---------------------------------------------------------------------*
8533 <TC - DECODING [0] EXPLICIT INTEGER (128), Short form - long form>
8541 BERPDU ::= [0] EXPLICIT INTEGER
8543 myIntegerValue BERPDU ::= 128
8549 import from TempA all;
8551 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8556 if (dec_BER_PDU('A00402020080'O) == myIntegerValue)
8559 {setverdict(pass);} else {setverdict(fail);}
8564 Overall verdict: pass
8570 .*---------------------------------------------------------------------*
8571 :h3. DECODING [0] EXPLICIT INTEGER (128), Long form - short form
8572 .*---------------------------------------------------------------------*
8575 <TC - DECODING [0] EXPLICIT INTEGER (128), Long form - short form>
8583 BERPDU ::= [0] EXPLICIT INTEGER
8585 myIntegerValue BERPDU ::= 128
8591 import from TempA all;
8593 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8598 if (dec_BER_PDU('A0810402020080'O) == myIntegerValue)
8601 {setverdict(pass);} else {setverdict(fail);}
8606 Overall verdict: pass
8612 .*---------------------------------------------------------------------*
8613 :h3. DECODING [0] EXPLICIT INTEGER (128), Long form Long form
8614 .*---------------------------------------------------------------------*
8617 <TC - DECODING [0] EXPLICIT INTEGER (128), Long form Long form>
8625 BERPDU ::= [0] EXPLICIT INTEGER
8627 myIntegerValue BERPDU ::= 128
8633 import from TempA all;
8635 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8640 if (dec_BER_PDU('A081050281020080'O) == myIntegerValue)
8643 {setverdict(pass);} else {setverdict(fail);}
8648 Overall verdict: pass
8654 .*---------------------------------------------------------------------*
8655 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Short form - Short form, DER
8656 .*---------------------------------------------------------------------*
8659 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Short form - Short form, DER>
8667 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
8669 myIntegerValue BERPDU ::= 128
8675 import from TempA all;
8677 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8682 if (dec_BER_PDU('E10402020080'O) == myIntegerValue)
8685 {setverdict(pass);} else {setverdict(fail);}
8690 Overall verdict: pass
8696 .*---------------------------------------------------------------------*
8697 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Short form - long form
8698 .*---------------------------------------------------------------------*
8701 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Short form - long form>
8709 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
8711 myIntegerValue BERPDU ::= 128
8717 import from TempA all;
8719 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8724 if (dec_BER_PDU('E1050281020080'O) == myIntegerValue)
8727 {setverdict(pass);} else {setverdict(fail);}
8732 Overall verdict: pass
8738 .*---------------------------------------------------------------------*
8739 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Long form - short form
8740 .*---------------------------------------------------------------------*
8743 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Long form - short form>
8751 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
8753 myIntegerValue BERPDU ::= 128
8759 import from TempA all;
8761 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8766 if (dec_BER_PDU('E1810402020080'O) == myIntegerValue)
8769 {setverdict(pass);} else {setverdict(fail);}
8774 Overall verdict: pass
8780 .*---------------------------------------------------------------------*
8781 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Long form Long form
8782 .*---------------------------------------------------------------------*
8785 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Long form Long form>
8793 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
8795 myIntegerValue BERPDU ::= 128
8801 import from TempA all;
8803 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8808 if (dec_BER_PDU('E181050281020080'O) == myIntegerValue)
8811 {setverdict(pass);} else {setverdict(fail);}
8816 Overall verdict: pass
8822 .*---------------------------------------------------------------------*
8823 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128),Indefinite form,CER
8824 .*---------------------------------------------------------------------*
8827 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128),Indefinite form,CER>
8835 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
8837 myIntegerValue BERPDU ::= 128
8843 import from TempA all;
8845 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8850 if (dec_BER_PDU('E180020200800000'O) == myIntegerValue)
8853 {setverdict(pass);} else {setverdict(fail);}
8858 Overall verdict: pass
8864 .*---------------------------------------------------------------------*
8865 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Short form - Short form, DER
8866 .*---------------------------------------------------------------------*
8869 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Short form - Short form, DER>
8877 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
8879 myIntegerValue BERPDU ::= 128
8885 import from TempA all;
8887 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8892 if (dec_BER_PDU('620402020080'O) == myIntegerValue)
8895 {setverdict(pass);} else {setverdict(fail);}
8900 Overall verdict: pass
8906 .*---------------------------------------------------------------------*
8907 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Short form - long form
8908 .*---------------------------------------------------------------------*
8911 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Short form - long form>
8919 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
8921 myIntegerValue BERPDU ::= 128
8927 import from TempA all;
8929 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8934 if (dec_BER_PDU('62050281020080'O) == myIntegerValue)
8937 {setverdict(pass);} else {setverdict(fail);}
8942 Overall verdict: pass
8948 .*---------------------------------------------------------------------*
8949 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Long form - short form
8950 .*---------------------------------------------------------------------*
8953 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Long form - short form>
8961 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
8963 myIntegerValue BERPDU ::= 128
8969 import from TempA all;
8971 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8976 if (dec_BER_PDU('62810402020080'O) == myIntegerValue)
8979 {setverdict(pass);} else {setverdict(fail);}
8984 Overall verdict: pass
8990 .*---------------------------------------------------------------------*
8991 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Long form Long form
8992 .*---------------------------------------------------------------------*
8995 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Long form Long form>
9003 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
9005 myIntegerValue BERPDU ::= 128
9011 import from TempA all;
9013 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9018 if (dec_BER_PDU('6281050281020080'O) == myIntegerValue)
9021 {setverdict(pass);} else {setverdict(fail);}
9026 Overall verdict: pass
9032 .*---------------------------------------------------------------------*
9033 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128),Indefinite form,CER
9034 .*---------------------------------------------------------------------*
9037 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128),Indefinite form,CER>
9045 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
9047 myIntegerValue BERPDU ::= 128
9053 import from TempA all;
9055 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9060 if (dec_BER_PDU('6280020200800000'O) == myIntegerValue)
9063 {setverdict(pass);} else {setverdict(fail);}
9068 Overall verdict: pass
9074 .*---------------------------------------------------------------------*
9075 :h3. DECODING [0] IMPLICIT INTEGER (128),Short form CER,DER
9076 .*---------------------------------------------------------------------*
9079 <TC - DECODING [0] IMPLICIT INTEGER (128),Short form CER,DER>
9087 BERPDU ::= [0] IMPLICIT INTEGER
9089 myIntegerValue BERPDU ::= 128
9095 import from TempA all;
9097 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9102 if (dec_BER_PDU('80020080'O) == myIntegerValue)
9105 {setverdict(pass);} else {setverdict(fail);}
9110 Overall verdict: pass
9116 .*---------------------------------------------------------------------*
9117 :h3. DECODING [0] IMPLICIT INTEGER (128),Long form
9118 .*---------------------------------------------------------------------*
9121 <TC - DECODING [0] IMPLICIT INTEGER (128),Long form>
9129 BERPDU ::= [0] IMPLICIT INTEGER
9131 myIntegerValue BERPDU ::= 128
9137 import from TempA all;
9139 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9144 if (dec_BER_PDU('8081020080'O) == myIntegerValue)
9147 {setverdict(pass);} else {setverdict(fail);}
9152 Overall verdict: pass
9158 .*---------------------------------------------------------------------*
9159 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (128),Short form CER,DER
9160 .*---------------------------------------------------------------------*
9163 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (128),Short form CER,DER>
9171 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
9173 myIntegerValue BERPDU ::= 128
9179 import from TempA all;
9181 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9186 if (dec_BER_PDU('C1020080'O) == myIntegerValue)
9189 {setverdict(pass);} else {setverdict(fail);}
9194 Overall verdict: pass
9200 .*---------------------------------------------------------------------*
9201 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (128),Long form
9202 .*---------------------------------------------------------------------*
9205 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (128),Long form>
9213 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
9215 myIntegerValue BERPDU ::= 128
9221 import from TempA all;
9223 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9228 if (dec_BER_PDU('C181020080'O) == myIntegerValue)
9231 {setverdict(pass);} else {setverdict(fail);}
9236 Overall verdict: pass
9242 .*---------------------------------------------------------------------*
9243 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (128),Short form CER,DER
9244 .*---------------------------------------------------------------------*
9247 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (128),Short form CER,DER>
9255 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
9257 myIntegerValue BERPDU ::= 128
9263 import from TempA all;
9265 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9270 if (dec_BER_PDU('42020080'O) == myIntegerValue)
9273 {setverdict(pass);} else {setverdict(fail);}
9278 Overall verdict: pass
9284 .*---------------------------------------------------------------------*
9285 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (128),Long form
9286 .*---------------------------------------------------------------------*
9289 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (128),Long form>
9297 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
9299 myIntegerValue BERPDU ::= 128
9305 import from TempA all;
9307 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9312 if (dec_BER_PDU('4281020080'O) == myIntegerValue)
9315 {setverdict(pass);} else {setverdict(fail);}
9320 Overall verdict: pass
9326 .*---------------------------------------------------------------------*
9327 :h3. DECODING INTEGER (-129), CER+DER
9328 .*---------------------------------------------------------------------*
9331 <TC - DECODING INTEGER (-129), CER+DER>
9341 myIntegerValue BERPDU ::= -129
9347 import from TempA all;
9349 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9354 if (dec_BER_PDU('0202FF7F'O) == myIntegerValue)
9357 {setverdict(pass);} else {setverdict(fail);}
9362 Overall verdict: pass
9368 .*---------------------------------------------------------------------*
9369 :h3. DECODING INTEGER (-129), (LENGTH OF LENGTH = 1)
9370 .*---------------------------------------------------------------------*
9373 <TC - DECODING INTEGER (-129), (LENGTH OF LENGTH = 1)>
9383 myIntegerValue BERPDU ::= -129
9389 import from TempA all;
9391 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9396 if (dec_BER_PDU('028102FF7F'O) == myIntegerValue)
9399 {setverdict(pass);} else {setverdict(fail);}
9404 Overall verdict: pass
9410 .*---------------------------------------------------------------------*
9411 :h3. DECODING INTEGER (-129), (LENGTH OF LENGTH = 2)
9412 .*---------------------------------------------------------------------*
9415 <TC - DECODING INTEGER (-129), (LENGTH OF LENGTH = 2)>
9425 myIntegerValue BERPDU ::= -129
9431 import from TempA all;
9433 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9438 if (dec_BER_PDU('02820002FF7F'O) == myIntegerValue)
9441 {setverdict(pass);} else {setverdict(fail);}
9446 Overall verdict: pass
9452 .*---------------------------------------------------------------------*
9453 :h3. DECODING [0] EXPLICIT INTEGER (-129), DER
9454 .*---------------------------------------------------------------------*
9457 <TC - DECODING [0] EXPLICIT INTEGER (-129), DER>
9465 BERPDU ::= [0] EXPLICIT INTEGER
9467 myIntegerValue BERPDU ::= -129
9473 import from TempA all;
9475 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9480 if (dec_BER_PDU('A0040202FF7F'O) == myIntegerValue)
9483 {setverdict(pass);} else {setverdict(fail);}
9488 Overall verdict: pass
9494 .*---------------------------------------------------------------------*
9495 :h3. DECODING [0] EXPLICIT INTEGER (-129), CER
9496 .*---------------------------------------------------------------------*
9499 <TC - DECODING [0] EXPLICIT INTEGER (-129), CER>
9507 BERPDU ::= [0] EXPLICIT INTEGER
9509 myIntegerValue BERPDU ::= -129
9515 import from TempA all;
9517 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9522 if (dec_BER_PDU('A0800202FF7F0000'O) == myIntegerValue)
9525 {setverdict(pass);} else {setverdict(fail);}
9530 Overall verdict: pass
9536 .*---------------------------------------------------------------------*
9537 :h3. DECODING [0] EXPLICIT INTEGER (-129), Short form - long form
9538 .*---------------------------------------------------------------------*
9541 <TC - DECODING [0] EXPLICIT INTEGER (-129), Short form - long form>
9549 BERPDU ::= [0] EXPLICIT INTEGER
9551 myIntegerValue BERPDU ::= -129
9557 import from TempA all;
9559 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9564 if (dec_BER_PDU('A0040202FF7F'O) == myIntegerValue)
9567 {setverdict(pass);} else {setverdict(fail);}
9572 Overall verdict: pass
9578 .*---------------------------------------------------------------------*
9579 :h3. DECODING [0] EXPLICIT INTEGER (-129), Long form - short form
9580 .*---------------------------------------------------------------------*
9583 <TC - DECODING [0] EXPLICIT INTEGER (-129), Long form - short form>
9591 BERPDU ::= [0] EXPLICIT INTEGER
9593 myIntegerValue BERPDU ::= -129
9599 import from TempA all;
9601 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9606 if (dec_BER_PDU('A081040202FF7F'O) == myIntegerValue)
9609 {setverdict(pass);} else {setverdict(fail);}
9614 Overall verdict: pass
9620 .*---------------------------------------------------------------------*
9621 :h3. DECODING [0] EXPLICIT INTEGER (-129), Long form Long form
9622 .*---------------------------------------------------------------------*
9625 <TC - DECODING [0] EXPLICIT INTEGER (-129), Long form Long form>
9633 BERPDU ::= [0] EXPLICIT INTEGER
9635 myIntegerValue BERPDU ::= -129
9641 import from TempA all;
9643 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9648 if (dec_BER_PDU('A08105028102FF7F'O) == myIntegerValue)
9651 {setverdict(pass);} else {setverdict(fail);}
9656 Overall verdict: pass
9662 .*---------------------------------------------------------------------*
9663 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Short form - Short form, DER
9664 .*---------------------------------------------------------------------*
9667 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Short form - Short form, DER>
9675 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
9677 myIntegerValue BERPDU ::= -129
9683 import from TempA all;
9685 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9690 if (dec_BER_PDU('E1040202FF7F'O) == myIntegerValue)
9693 {setverdict(pass);} else {setverdict(fail);}
9698 Overall verdict: pass
9704 .*---------------------------------------------------------------------*
9705 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Short form - long form
9706 .*---------------------------------------------------------------------*
9709 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Short form - long form>
9717 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
9719 myIntegerValue BERPDU ::= -129
9725 import from TempA all;
9727 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9732 if (dec_BER_PDU('E105028102FF7F'O) == myIntegerValue)
9735 {setverdict(pass);} else {setverdict(fail);}
9740 Overall verdict: pass
9746 .*---------------------------------------------------------------------*
9747 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Long form - short form
9748 .*---------------------------------------------------------------------*
9751 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Long form - short form>
9759 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
9761 myIntegerValue BERPDU ::= -129
9767 import from TempA all;
9769 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9774 if (dec_BER_PDU('E181040202FF7F'O) == myIntegerValue)
9777 {setverdict(pass);} else {setverdict(fail);}
9782 Overall verdict: pass
9788 .*---------------------------------------------------------------------*
9789 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Long form Long form
9790 .*---------------------------------------------------------------------*
9793 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Long form Long form>
9801 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
9803 myIntegerValue BERPDU ::= -129
9809 import from TempA all;
9811 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9816 if (dec_BER_PDU('E18105028102FF7F'O) == myIntegerValue)
9819 {setverdict(pass);} else {setverdict(fail);}
9824 Overall verdict: pass
9830 .*---------------------------------------------------------------------*
9831 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129),Indefinite form,CER
9832 .*---------------------------------------------------------------------*
9835 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129),Indefinite form,CER>
9843 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
9845 myIntegerValue BERPDU ::= -129
9851 import from TempA all;
9853 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9858 if (dec_BER_PDU('E1800202FF7F0000'O) == myIntegerValue)
9861 {setverdict(pass);} else {setverdict(fail);}
9866 Overall verdict: pass
9872 .*---------------------------------------------------------------------*
9873 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Short form - Short form, DER
9874 .*---------------------------------------------------------------------*
9877 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Short form - Short form, DER>
9885 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
9887 myIntegerValue BERPDU ::= -129
9893 import from TempA all;
9895 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9900 if (dec_BER_PDU('62040202FF7F'O) == myIntegerValue)
9903 {setverdict(pass);} else {setverdict(fail);}
9908 Overall verdict: pass
9914 .*---------------------------------------------------------------------*
9915 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Short form - long form
9916 .*---------------------------------------------------------------------*
9919 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Short form - long form>
9927 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
9929 myIntegerValue BERPDU ::= -129
9935 import from TempA all;
9937 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9942 if (dec_BER_PDU('6205028102FF7F'O) == myIntegerValue)
9945 {setverdict(pass);} else {setverdict(fail);}
9950 Overall verdict: pass
9956 .*---------------------------------------------------------------------*
9957 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Long form - short form
9958 .*---------------------------------------------------------------------*
9961 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Long form - short form>
9969 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
9971 myIntegerValue BERPDU ::= -129
9977 import from TempA all;
9979 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9984 if (dec_BER_PDU('6281040202FF7F'O) == myIntegerValue)
9987 {setverdict(pass);} else {setverdict(fail);}
9992 Overall verdict: pass
9998 .*---------------------------------------------------------------------*
9999 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Long form Long form
10000 .*---------------------------------------------------------------------*
10003 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Long form Long form>
10011 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
10013 myIntegerValue BERPDU ::= -129
10019 import from TempA all;
10021 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10026 if (dec_BER_PDU('628105028102FF7F'O) == myIntegerValue)
10029 {setverdict(pass);} else {setverdict(fail);}
10034 Overall verdict: pass
10040 .*---------------------------------------------------------------------*
10041 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129),Indefinite form,CER
10042 .*---------------------------------------------------------------------*
10045 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129),Indefinite form,CER>
10053 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
10055 myIntegerValue BERPDU ::= -129
10061 import from TempA all;
10063 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10068 if (dec_BER_PDU('62800202FF7F0000'O) == myIntegerValue)
10071 {setverdict(pass);} else {setverdict(fail);}
10076 Overall verdict: pass
10082 .*---------------------------------------------------------------------*
10083 :h3. DECODING [0] IMPLICIT INTEGER (-129),Short form CER,DER
10084 .*---------------------------------------------------------------------*
10087 <TC - DECODING [0] IMPLICIT INTEGER (-129),Short form CER,DER>
10095 BERPDU ::= [0] IMPLICIT INTEGER
10097 myIntegerValue BERPDU ::= -129
10103 import from TempA all;
10105 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10110 if (dec_BER_PDU('8002FF7F'O) == myIntegerValue)
10113 {setverdict(pass);} else {setverdict(fail);}
10118 Overall verdict: pass
10124 .*---------------------------------------------------------------------*
10125 :h3. DECODING [0] IMPLICIT INTEGER (-129),Long form
10126 .*---------------------------------------------------------------------*
10129 <TC - DECODING [0] IMPLICIT INTEGER (-129),Long form>
10137 BERPDU ::= [0] IMPLICIT INTEGER
10139 myIntegerValue BERPDU ::= -129
10145 import from TempA all;
10147 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10152 if (dec_BER_PDU('808102FF7F'O) == myIntegerValue)
10155 {setverdict(pass);} else {setverdict(fail);}
10160 Overall verdict: pass
10166 .*---------------------------------------------------------------------*
10167 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-129),Short form CER,DER
10168 .*---------------------------------------------------------------------*
10171 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-129),Short form CER,DER>
10179 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
10181 myIntegerValue BERPDU ::= -129
10187 import from TempA all;
10189 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10194 if (dec_BER_PDU('C102FF7F'O) == myIntegerValue)
10197 {setverdict(pass);} else {setverdict(fail);}
10202 Overall verdict: pass
10208 .*---------------------------------------------------------------------*
10209 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-129),Long form
10210 .*---------------------------------------------------------------------*
10213 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-129),Long form>
10221 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
10223 myIntegerValue BERPDU ::= -129
10229 import from TempA all;
10231 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10236 if (dec_BER_PDU('C18102FF7F'O) == myIntegerValue)
10239 {setverdict(pass);} else {setverdict(fail);}
10244 Overall verdict: pass
10250 .*---------------------------------------------------------------------*
10251 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-129),Short form CER,DER
10252 .*---------------------------------------------------------------------*
10255 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-129),Short form CER,DER>
10263 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
10265 myIntegerValue BERPDU ::= -129
10271 import from TempA all;
10273 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10278 if (dec_BER_PDU('4202FF7F'O) == myIntegerValue)
10281 {setverdict(pass);} else {setverdict(fail);}
10286 Overall verdict: pass
10292 .*---------------------------------------------------------------------*
10293 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-129),Long form
10294 .*---------------------------------------------------------------------*
10297 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-129),Long form>
10305 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
10307 myIntegerValue BERPDU ::= -129
10313 import from TempA all;
10315 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10320 if (dec_BER_PDU('428102FF7F'O) == myIntegerValue)
10323 {setverdict(pass);} else {setverdict(fail);}
10328 Overall verdict: pass
10334 .*---------------------------------------------------------------------*
10335 :h3. DECODING DER integer (5) with Context Specific TAG = 30
10336 .*---------------------------------------------------------------------*
10339 <TC - DECODING DER integer (5) with Context Specific TAG = 30>
10347 BERPDU ::= [30] EXPLICIT INTEGER
10349 myIntegerValue BERPDU ::= 5
10355 import from TempA all;
10357 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10362 if (dec_BER_PDU('BE03020105'O) == myIntegerValue)
10365 {setverdict(pass);} else {setverdict(fail);}
10370 Overall verdict: pass
10376 .*---------------------------------------------------------------------*
10377 :h3. DECODING CER integer (5) with Context Specific TAG = 30
10378 .*---------------------------------------------------------------------*
10381 <TC - DECODING CER integer (5) with Context Specific TAG = 30>
10389 BERPDU ::= [30] EXPLICIT INTEGER
10391 myIntegerValue BERPDU ::= 5
10397 import from TempA all;
10399 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10404 if (dec_BER_PDU('BE800201050000'O) == myIntegerValue)
10407 {setverdict(pass);} else {setverdict(fail);}
10412 Overall verdict: pass
10418 .*---------------------------------------------------------------------*
10419 :h3. DECODING DER integer (5) with Context Specific TAG = 31
10420 .*---------------------------------------------------------------------*
10423 <TC - DECODING DER integer (5) with Context Specific TAG = 31>
10431 BERPDU ::= [31] EXPLICIT INTEGER
10433 myIntegerValue BERPDU ::= 5
10439 import from TempA all;
10441 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10446 if (dec_BER_PDU('BF1F03020105'O) == myIntegerValue)
10449 {setverdict(pass);} else {setverdict(fail);}
10454 Overall verdict: pass
10460 .*---------------------------------------------------------------------*
10461 :h3. DECODING CER integer (5) with Context Specific TAG = 31
10462 .*---------------------------------------------------------------------*
10465 <TC - DECODING CER integer (5) with Context Specific TAG = 31>
10473 BERPDU ::= [31] EXPLICIT INTEGER
10475 myIntegerValue BERPDU ::= 5
10481 import from TempA all;
10483 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10488 if (dec_BER_PDU('BF1F800201050000'O) == myIntegerValue)
10491 {setverdict(pass);} else {setverdict(fail);}
10496 Overall verdict: pass
10502 .*---------------------------------------------------------------------*
10503 :h3. DECODING DER integer (5) with Context Specific TAG = 127
10504 .*---------------------------------------------------------------------*
10507 <TC - DECODING DER integer (5) with Context Specific TAG = 127>
10515 BERPDU ::= [127] EXPLICIT INTEGER
10517 myIntegerValue BERPDU ::= 5
10523 import from TempA all;
10525 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10530 if (dec_BER_PDU('BF7F03020105'O) == myIntegerValue)
10533 {setverdict(pass);} else {setverdict(fail);}
10538 Overall verdict: pass
10544 .*---------------------------------------------------------------------*
10545 :h3. DECODING CER integer (5) with Context Specific TAG = 127
10546 .*---------------------------------------------------------------------*
10549 <TC - DECODING CER integer (5) with Context Specific TAG = 127>
10557 BERPDU ::= [127] EXPLICIT INTEGER
10559 myIntegerValue BERPDU ::= 5
10565 import from TempA all;
10567 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10572 if (dec_BER_PDU('BF7F800201050000'O) == myIntegerValue)
10575 {setverdict(pass);} else {setverdict(fail);}
10580 Overall verdict: pass
10586 .*---------------------------------------------------------------------*
10587 :h3. DECODING DER integer (5) with Context Specific TAG = 128
10588 .*---------------------------------------------------------------------*
10591 <TC - DECODING DER integer (5) with Context Specific TAG = 128>
10599 BERPDU ::= [128] EXPLICIT INTEGER
10601 myIntegerValue BERPDU ::= 5
10607 import from TempA all;
10609 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10614 if (dec_BER_PDU('BF810003020105'O) == myIntegerValue)
10617 {setverdict(pass);} else {setverdict(fail);}
10622 Overall verdict: pass
10628 .*---------------------------------------------------------------------*
10629 :h3. DECODING CER integer (5) with Context Specific TAG = 128
10630 .*---------------------------------------------------------------------*
10633 <TC - DECODING CER integer (5) with Context Specific TAG = 128>
10641 BERPDU ::= [128] EXPLICIT INTEGER
10643 myIntegerValue BERPDU ::= 5
10649 import from TempA all;
10651 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10656 if (dec_BER_PDU('BF8100800201050000'O) == myIntegerValue)
10659 {setverdict(pass);} else {setverdict(fail);}
10664 Overall verdict: pass
10670 .*---------------------------------------------------------------------*
10671 :h3. DECODING DER integer (5) with Context Specific TAG = 16383
10672 .*---------------------------------------------------------------------*
10675 <TC - DECODING DER integer (5) with Context Specific TAG = 16383>
10683 BERPDU ::= [16383] EXPLICIT INTEGER
10685 myIntegerValue BERPDU ::= 5
10691 import from TempA all;
10693 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10698 if (dec_BER_PDU('BFFF7F03020105'O) == myIntegerValue)
10701 {setverdict(pass);} else {setverdict(fail);}
10706 Overall verdict: pass
10712 .*---------------------------------------------------------------------*
10713 :h3. DECODING CER integer (5) with Context Specific TAG = 16383
10714 .*---------------------------------------------------------------------*
10717 <TC - DECODING CER integer (5) with Context Specific TAG = 16383>
10725 BERPDU ::= [16383] EXPLICIT INTEGER
10727 myIntegerValue BERPDU ::= 5
10733 import from TempA all;
10735 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10740 if (dec_BER_PDU('BFFF7F800201050000'O) == myIntegerValue)
10743 {setverdict(pass);} else {setverdict(fail);}
10748 Overall verdict: pass
10754 .*---------------------------------------------------------------------*
10755 :h3. DECODING DER integer (5) with Context Specific TAG = 16384
10756 .*---------------------------------------------------------------------*
10759 <TC - DECODING DER integer (5) with Context Specific TAG = 16384>
10767 BERPDU ::= [16384] EXPLICIT INTEGER
10769 myIntegerValue BERPDU ::= 5
10775 import from TempA all;
10777 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10782 if (dec_BER_PDU('BF81800003020105'O) == myIntegerValue)
10785 {setverdict(pass);} else {setverdict(fail);}
10790 Overall verdict: pass
10796 .*---------------------------------------------------------------------*
10797 :h3. DECODING CER integer (5) with Context Specific TAG = 16384
10798 .*---------------------------------------------------------------------*
10801 <TC - DECODING CER integer (5) with Context Specific TAG = 16384>
10809 BERPDU ::= [16384] EXPLICIT INTEGER
10811 myIntegerValue BERPDU ::= 5
10817 import from TempA all;
10819 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10824 if (dec_BER_PDU('BF818000800201050000'O) == myIntegerValue)
10827 {setverdict(pass);} else {setverdict(fail);}
10832 Overall verdict: pass
10838 .*---------------------------------------------------------------------*
10839 :h3. DER + CER encoding of ENUMERATED third(-9) hardcoded positive
10840 .*---------------------------------------------------------------------*
10843 <TC - DER + CER encoding of ENUMERATED third(-9) hardcoded positive >
10851 BERPDU ::= ENUMERATED {first(-5), second(0), third(9)}
10856 import from TempA all;
10857 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
10858 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
10860 const BERPDU b := third
10864 if ((enc_DER_PDU(b) == '0A0109'O)and(enc_CER_PDU(b) == '0A0109'O)) {setverdict(pass);} else {setverdict(fail);}
10868 Overall verdict: pass
10874 .*---------------------------------------------------------------------*
10875 :h3. DER + CER encoding of ENUMERATED first(0) hardcoded negative
10876 .*---------------------------------------------------------------------*
10879 <TC - DER + CER encoding of ENUMERATED first(0) hardcoded negative>
10887 BERPDU ::= ENUMERATED {first(-5), second(0), third(9)}
10892 import from TempA all;
10893 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
10894 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
10896 const BERPDU b := first
10900 if ((enc_DER_PDU(b) == '0A01FB'O)and(enc_CER_PDU(b) == '0A01FB'O)) {setverdict(pass);} else {setverdict(fail);}
10904 Overall verdict: pass
10910 .*---------------------------------------------------------------------*
10911 :h3. DER + CER encoding of ENUMERATED second(0) hardcoded zero
10912 .*---------------------------------------------------------------------*
10915 <TC - DER + CER encoding of ENUMERATED second(0) hardcoded zero>
10923 BERPDU ::= ENUMERATED {first(-5), second(0), third(9)}
10928 import from TempA all;
10929 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
10930 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
10932 const BERPDU b := second
10936 if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);}
10940 Overall verdict: pass
10946 .*---------------------------------------------------------------------*
10947 :h3. DER + CER encoding of ENUMERATED third, no hardcoding
10948 .*---------------------------------------------------------------------*
10951 <TC - DER + CER encoding of ENUMERATED third, no hardcoding>
10959 BERPDU ::= ENUMERATED {first, second, third}
10964 import from TempA all;
10965 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
10966 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
10968 const BERPDU b := third
10972 if ((enc_DER_PDU(b) == '0A0102'O)and(enc_CER_PDU(b) == '0A0102'O)) {setverdict(pass);} else {setverdict(fail);}
10976 Overall verdict: pass
10982 .*---------------------------------------------------------------------*
10983 :h3. DER + CER encoding of ENUMERATED first, no hardcoding
10984 .*---------------------------------------------------------------------*
10987 <TC - DER + CER encoding of ENUMERATED first, no hardcoding>
10995 BERPDU ::= ENUMERATED {first, second, third}
11000 import from TempA all;
11001 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11002 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11004 const BERPDU b := first
11008 if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);}
11012 Overall verdict: pass
11018 .*---------------------------------------------------------------------*
11019 :h3. DER + CER encoding of ENUMERATED second, no hardcoding
11020 .*---------------------------------------------------------------------*
11023 <TC - DER + CER encoding of ENUMERATED second, no hardcoding>
11031 BERPDU ::= ENUMERATED {first(-5), second(0), third(9)}
11036 import from TempA all;
11037 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11038 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11040 const BERPDU b := second
11044 if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);}
11048 Overall verdict: pass
11054 .*---------------------------------------------------------------------*
11055 :h3. DER + CER encoding of ENUMERATED first
11056 .*---------------------------------------------------------------------*
11059 <TC - DER + CER encoding of ENUMERATED first>
11067 BERPDU ::= ENUMERATED {first, second(0),third}
11072 import from TempA all;
11073 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11074 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11076 const BERPDU b := first
11080 if ((enc_DER_PDU(b) == '0A0101'O)and(enc_CER_PDU(b) == '0A0101'O)) {setverdict(pass);} else {setverdict(fail);}
11084 Overall verdict: pass
11090 .*---------------------------------------------------------------------*
11091 :h3. DER + CER encoding of ENUMERATED second(0)
11092 .*---------------------------------------------------------------------*
11095 <TC - DER + CER encoding of ENUMERATED second(0)>
11103 BERPDU ::= ENUMERATED {first, second(0),third}
11108 import from TempA all;
11109 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11110 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11112 const BERPDU b := second
11116 if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);}
11120 Overall verdict: pass
11126 .*---------------------------------------------------------------------*
11127 :h3. DER + CER encoding of ENUMERATED third
11128 .*---------------------------------------------------------------------*
11131 <TC - DER + CER encoding of ENUMERATED third>
11139 BERPDU ::= ENUMERATED {first, second(0),third}
11144 import from TempA all;
11145 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11146 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11148 const BERPDU b := third
11152 if ((enc_DER_PDU(b) == '0A0102'O)and(enc_CER_PDU(b) == '0A0102'O)) {setverdict(pass);} else {setverdict(fail);}
11156 Overall verdict: pass
11162 .*---------------------------------------------------------------------*
11163 :h3. DER + CER encoding of ENUMERATED first
11164 .*---------------------------------------------------------------------*
11167 <TC - DER + CER encoding of ENUMERATED first>
11175 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11180 import from TempA all;
11181 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11182 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11184 const BERPDU b := first
11188 if ((enc_DER_PDU(b) == '0A0101'O)and(enc_CER_PDU(b) == '0A0101'O)) {setverdict(pass);} else {setverdict(fail);}
11192 Overall verdict: pass
11198 .*---------------------------------------------------------------------*
11199 :h3. DER + CER encoding of ENUMERATED second(0)
11200 .*---------------------------------------------------------------------*
11203 <TC - DER + CER encoding of ENUMERATED second(0)>
11211 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11216 import from TempA all;
11217 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11218 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11220 const BERPDU b := second
11224 if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);}
11228 Overall verdict: pass
11234 .*---------------------------------------------------------------------*
11235 :h3. DER + CER encoding of ENUMERATED third
11236 .*---------------------------------------------------------------------*
11239 <TC - DER + CER encoding of ENUMERATED third>
11247 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11252 import from TempA all;
11253 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11254 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11256 const BERPDU b := third
11260 if ((enc_DER_PDU(b) == '0A0102'O)and(enc_CER_PDU(b) == '0A0102'O)) {setverdict(pass);} else {setverdict(fail);}
11264 Overall verdict: pass
11270 .*---------------------------------------------------------------------*
11271 :h3. DER + CER encoding of ENUMERATED fourth (after extension ...)
11272 .*---------------------------------------------------------------------*
11275 <TC - DER + CER encoding of ENUMERATED fourth (after extension ...)>
11283 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11288 import from TempA all;
11289 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11290 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11292 const BERPDU b := fourth
11296 if ((enc_DER_PDU(b) == '0A0103'O)and(enc_CER_PDU(b) == '0A0103'O)) {setverdict(pass);} else {setverdict(fail);}
11300 Overall verdict: pass
11306 .*---------------------------------------------------------------------*
11307 :h3. DER + CER encoding of ENUMERATED fifth(5) (after extension ...)
11308 .*---------------------------------------------------------------------*
11311 <TC - DER + CER encoding of ENUMERATED fifth(5) (after extension ...)>
11319 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11324 import from TempA all;
11325 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11326 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11328 const BERPDU b := fifth
11332 if ((enc_DER_PDU(b) == '0A0105'O)and(enc_CER_PDU(b) == '0A0105'O)) {setverdict(pass);} else {setverdict(fail);}
11336 Overall verdict: pass
11342 .*---------------------------------------------------------------------*
11343 :h3. DER + CER encoding of ENUMERATED sixth (after extension ...)
11344 .*---------------------------------------------------------------------*
11347 <TC - DER + CER encoding of ENUMERATED sixth (after extension ...)>
11355 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11360 import from TempA all;
11361 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11362 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11364 const BERPDU b := sixth
11368 if ((enc_DER_PDU(b) == '0A0106'O)and(enc_CER_PDU(b) == '0A0106'O)) {setverdict(pass);} else {setverdict(fail);}
11372 Overall verdict: pass
11378 .*---------------------------------------------------------------------*
11379 :h3. DER + CER encoding of ENUMERATED , tagged, EXPLICIT
11380 .*---------------------------------------------------------------------*
11383 <TC - DER + CER encoding of ENUMERATED , tagged, EXPLICIT>
11391 BERPDU ::= [21] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11396 import from TempA all;
11397 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11398 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11400 const BERPDU b := sixth
11404 if ((enc_DER_PDU(b) == 'B5030A0106'O)and(enc_CER_PDU(b) == 'B5800A01060000'O)) {setverdict(pass);} else {setverdict(fail);}
11408 Overall verdict: pass
11414 .*---------------------------------------------------------------------*
11415 :h3. DER + CER encoding of ENUMERATED , tagged, IMPLICIT
11416 .*---------------------------------------------------------------------*
11419 <TC - DER + CER encoding of ENUMERATED , tagged, IMPLICIT>
11427 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11432 import from TempA all;
11433 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11434 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11436 const BERPDU b := sixth
11440 if ((enc_DER_PDU(b) == '9F580106'O)and(enc_CER_PDU(b) == '9F580106'O)) {setverdict(pass);} else {setverdict(fail);}
11444 Overall verdict: pass
11450 .*---------------------------------------------------------------------*
11451 :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (first)
11452 .*---------------------------------------------------------------------*
11455 <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (first)>
11456 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11464 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11467 myValue BERPDU ::= first
11475 import from TempA all;
11477 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11482 if (dec_BER_PDU('0A0101'O) == myValue)
11484 {setverdict(pass);} else {setverdict(fail);}
11489 Overall verdict: pass
11495 .*---------------------------------------------------------------------*
11496 :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (first)
11497 .*---------------------------------------------------------------------*
11500 <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (first)>
11501 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11509 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11512 myValue BERPDU ::= first
11520 import from TempA all;
11522 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11527 if (dec_BER_PDU('0A810101'O) == myValue)
11529 {setverdict(pass);} else {setverdict(fail);}
11534 Overall verdict: pass
11540 .*---------------------------------------------------------------------*
11541 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (first)
11542 .*---------------------------------------------------------------------*
11545 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (first)>
11546 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11554 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11557 myValue BERPDU ::= first
11565 import from TempA all;
11567 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11572 if (dec_BER_PDU('A0030A0101'O) == myValue)
11574 {setverdict(pass);} else {setverdict(fail);}
11579 Overall verdict: pass
11585 .*---------------------------------------------------------------------*
11586 :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (first)
11587 .*---------------------------------------------------------------------*
11590 <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (first)>
11591 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11599 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11602 myValue BERPDU ::= first
11610 import from TempA all;
11612 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11617 if (dec_BER_PDU('A0800A01010000'O) == myValue)
11619 {setverdict(pass);} else {setverdict(fail);}
11624 Overall verdict: pass
11630 .*---------------------------------------------------------------------*
11631 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (first)
11632 .*---------------------------------------------------------------------*
11635 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (first)>
11636 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11644 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11647 myValue BERPDU ::= first
11655 import from TempA all;
11657 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11662 if (dec_BER_PDU('A0040A810101'O) == myValue)
11664 {setverdict(pass);} else {setverdict(fail);}
11669 Overall verdict: pass
11675 .*---------------------------------------------------------------------*
11676 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (first)
11677 .*---------------------------------------------------------------------*
11680 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (first)>
11681 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11689 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11692 myValue BERPDU ::= first
11700 import from TempA all;
11702 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11707 if (dec_BER_PDU('A081040A810101'O) == myValue)
11709 {setverdict(pass);} else {setverdict(fail);}
11714 Overall verdict: pass
11720 .*---------------------------------------------------------------------*
11721 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (first)
11722 .*---------------------------------------------------------------------*
11725 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (first)>
11726 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11734 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11737 myValue BERPDU ::= first
11745 import from TempA all;
11747 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11752 if (dec_BER_PDU('9F580101'O) == myValue)
11754 {setverdict(pass);} else {setverdict(fail);}
11759 Overall verdict: pass
11765 .*---------------------------------------------------------------------*
11766 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (first)
11767 .*---------------------------------------------------------------------*
11770 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (first)>
11771 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11779 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11782 myValue BERPDU ::= first
11790 import from TempA all;
11792 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11797 if (dec_BER_PDU('9F58810101'O) == myValue)
11799 {setverdict(pass);} else {setverdict(fail);}
11804 Overall verdict: pass
11810 .*---------------------------------------------------------------------*
11811 :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (second(0))
11812 .*---------------------------------------------------------------------*
11815 <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (second(0))>
11816 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11824 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11827 myValue BERPDU ::= second
11835 import from TempA all;
11837 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11842 if (dec_BER_PDU('0A0100'O) == myValue)
11844 {setverdict(pass);} else {setverdict(fail);}
11849 Overall verdict: pass
11855 .*---------------------------------------------------------------------*
11856 :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (second(0))
11857 .*---------------------------------------------------------------------*
11860 <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (second(0))>
11861 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11869 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11872 myValue BERPDU ::= second
11880 import from TempA all;
11882 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11887 if (dec_BER_PDU('0A810100'O) == myValue)
11889 {setverdict(pass);} else {setverdict(fail);}
11894 Overall verdict: pass
11900 .*---------------------------------------------------------------------*
11901 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (second(0))
11902 .*---------------------------------------------------------------------*
11905 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (second(0))>
11906 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11914 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11917 myValue BERPDU ::= second
11925 import from TempA all;
11927 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11932 if (dec_BER_PDU('A0030A0100'O) == myValue)
11934 {setverdict(pass);} else {setverdict(fail);}
11939 Overall verdict: pass
11945 .*---------------------------------------------------------------------*
11946 :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (second(0))
11947 .*---------------------------------------------------------------------*
11950 <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (second(0))>
11951 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11959 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11962 myValue BERPDU ::= second
11970 import from TempA all;
11972 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11977 if (dec_BER_PDU('A0800A01000000'O) == myValue)
11979 {setverdict(pass);} else {setverdict(fail);}
11984 Overall verdict: pass
11990 .*---------------------------------------------------------------------*
11991 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (second(0))
11992 .*---------------------------------------------------------------------*
11995 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (second(0))>
11996 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12004 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12007 myValue BERPDU ::= second
12015 import from TempA all;
12017 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12022 if (dec_BER_PDU('A0040A810100'O) == myValue)
12024 {setverdict(pass);} else {setverdict(fail);}
12029 Overall verdict: pass
12035 .*---------------------------------------------------------------------*
12036 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (second(0))
12037 .*---------------------------------------------------------------------*
12040 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (second(0))>
12041 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12049 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12052 myValue BERPDU ::= second
12060 import from TempA all;
12062 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12067 if (dec_BER_PDU('A081040A810100'O) == myValue)
12069 {setverdict(pass);} else {setverdict(fail);}
12074 Overall verdict: pass
12080 .*---------------------------------------------------------------------*
12081 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (second(0))
12082 .*---------------------------------------------------------------------*
12085 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (second(0))>
12086 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12094 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12097 myValue BERPDU ::= second
12105 import from TempA all;
12107 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12112 if (dec_BER_PDU('9F580100'O) == myValue)
12114 {setverdict(pass);} else {setverdict(fail);}
12119 Overall verdict: pass
12125 .*---------------------------------------------------------------------*
12126 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (second(0))
12127 .*---------------------------------------------------------------------*
12130 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (second(0))>
12131 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12139 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12142 myValue BERPDU ::= second
12150 import from TempA all;
12152 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12157 if (dec_BER_PDU('9F58810100'O) == myValue)
12159 {setverdict(pass);} else {setverdict(fail);}
12164 Overall verdict: pass
12170 .*---------------------------------------------------------------------*
12171 :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (third)
12172 .*---------------------------------------------------------------------*
12175 <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (third)>
12176 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12184 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12187 myValue BERPDU ::= third
12195 import from TempA all;
12197 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12202 if (dec_BER_PDU('0A0102'O) == myValue)
12204 {setverdict(pass);} else {setverdict(fail);}
12209 Overall verdict: pass
12215 .*---------------------------------------------------------------------*
12216 :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (third)
12217 .*---------------------------------------------------------------------*
12220 <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (third)>
12221 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12229 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12232 myValue BERPDU ::= third
12240 import from TempA all;
12242 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12247 if (dec_BER_PDU('0A810102'O) == myValue)
12249 {setverdict(pass);} else {setverdict(fail);}
12254 Overall verdict: pass
12260 .*---------------------------------------------------------------------*
12261 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (third)
12262 .*---------------------------------------------------------------------*
12265 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (third)>
12266 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12274 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12277 myValue BERPDU ::= third
12285 import from TempA all;
12287 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12292 if (dec_BER_PDU('A0030A0102'O) == myValue)
12294 {setverdict(pass);} else {setverdict(fail);}
12299 Overall verdict: pass
12305 .*---------------------------------------------------------------------*
12306 :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (third)
12307 .*---------------------------------------------------------------------*
12310 <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (third)>
12311 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12319 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12322 myValue BERPDU ::= third
12330 import from TempA all;
12332 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12337 if (dec_BER_PDU('A0800A01020000'O) == myValue)
12339 {setverdict(pass);} else {setverdict(fail);}
12344 Overall verdict: pass
12350 .*---------------------------------------------------------------------*
12351 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (third)
12352 .*---------------------------------------------------------------------*
12355 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (third)>
12356 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12364 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12367 myValue BERPDU ::= third
12375 import from TempA all;
12377 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12382 if (dec_BER_PDU('A0040A810102'O) == myValue)
12384 {setverdict(pass);} else {setverdict(fail);}
12389 Overall verdict: pass
12395 .*---------------------------------------------------------------------*
12396 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (third)
12397 .*---------------------------------------------------------------------*
12400 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (third)>
12401 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12409 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12412 myValue BERPDU ::= third
12420 import from TempA all;
12422 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12427 if (dec_BER_PDU('A081040A810102'O) == myValue)
12429 {setverdict(pass);} else {setverdict(fail);}
12434 Overall verdict: pass
12440 .*---------------------------------------------------------------------*
12441 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (third)
12442 .*---------------------------------------------------------------------*
12445 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (third)>
12446 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12454 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12457 myValue BERPDU ::= third
12465 import from TempA all;
12467 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12472 if (dec_BER_PDU('9F580102'O) == myValue)
12474 {setverdict(pass);} else {setverdict(fail);}
12479 Overall verdict: pass
12485 .*---------------------------------------------------------------------*
12486 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (third)
12487 .*---------------------------------------------------------------------*
12490 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (third)>
12491 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12499 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12502 myValue BERPDU ::= third
12510 import from TempA all;
12512 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12517 if (dec_BER_PDU('9F58810102'O) == myValue)
12519 {setverdict(pass);} else {setverdict(fail);}
12524 Overall verdict: pass
12530 .*---------------------------------------------------------------------*
12531 :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (fourth)
12532 .*---------------------------------------------------------------------*
12535 <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (fourth)>
12536 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12544 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12547 myValue BERPDU ::= fourth
12555 import from TempA all;
12557 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12562 if (dec_BER_PDU('0A0103'O) == myValue)
12564 {setverdict(pass);} else {setverdict(fail);}
12569 Overall verdict: pass
12575 .*---------------------------------------------------------------------*
12576 :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (fourth)
12577 .*---------------------------------------------------------------------*
12580 <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (fourth)>
12581 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12589 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12592 myValue BERPDU ::= fourth
12600 import from TempA all;
12602 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12607 if (dec_BER_PDU('0A810103'O) == myValue)
12609 {setverdict(pass);} else {setverdict(fail);}
12614 Overall verdict: pass
12620 .*---------------------------------------------------------------------*
12621 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (fourth)
12622 .*---------------------------------------------------------------------*
12625 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (fourth)>
12626 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12634 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12637 myValue BERPDU ::= fourth
12645 import from TempA all;
12647 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12652 if (dec_BER_PDU('A0030A0103'O) == myValue)
12654 {setverdict(pass);} else {setverdict(fail);}
12659 Overall verdict: pass
12665 .*---------------------------------------------------------------------*
12666 :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (fourth)
12667 .*---------------------------------------------------------------------*
12670 <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (fourth)>
12671 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12679 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12682 myValue BERPDU ::= fourth
12690 import from TempA all;
12692 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12697 if (dec_BER_PDU('A0800A01030000'O) == myValue)
12699 {setverdict(pass);} else {setverdict(fail);}
12704 Overall verdict: pass
12710 .*---------------------------------------------------------------------*
12711 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (fourth)
12712 .*---------------------------------------------------------------------*
12715 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (fourth)>
12716 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12724 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12727 myValue BERPDU ::= fourth
12735 import from TempA all;
12737 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12742 if (dec_BER_PDU('A0040A810103'O) == myValue)
12744 {setverdict(pass);} else {setverdict(fail);}
12749 Overall verdict: pass
12755 .*---------------------------------------------------------------------*
12756 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (fourth)
12757 .*---------------------------------------------------------------------*
12760 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (fourth)>
12761 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12769 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12772 myValue BERPDU ::= fourth
12780 import from TempA all;
12782 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12787 if (dec_BER_PDU('A081040A810103'O) == myValue)
12789 {setverdict(pass);} else {setverdict(fail);}
12794 Overall verdict: pass
12800 .*---------------------------------------------------------------------*
12801 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (fourth)
12802 .*---------------------------------------------------------------------*
12805 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (fourth)>
12806 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12814 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12817 myValue BERPDU ::= fourth
12825 import from TempA all;
12827 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12832 if (dec_BER_PDU('9F580103'O) == myValue)
12834 {setverdict(pass);} else {setverdict(fail);}
12839 Overall verdict: pass
12845 .*---------------------------------------------------------------------*
12846 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (fourth)
12847 .*---------------------------------------------------------------------*
12850 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (fourth)>
12851 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12859 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12862 myValue BERPDU ::= fourth
12870 import from TempA all;
12872 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12877 if (dec_BER_PDU('9F58810103'O) == myValue)
12879 {setverdict(pass);} else {setverdict(fail);}
12884 Overall verdict: pass
12890 .*---------------------------------------------------------------------*
12891 :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (fifth(5))
12892 .*---------------------------------------------------------------------*
12895 <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (fifth(5))>
12896 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12904 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12907 myValue BERPDU ::= fifth
12915 import from TempA all;
12917 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12922 if (dec_BER_PDU('0A0105'O) == myValue)
12924 {setverdict(pass);} else {setverdict(fail);}
12929 Overall verdict: pass
12935 .*---------------------------------------------------------------------*
12936 :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (fifth(5))
12937 .*---------------------------------------------------------------------*
12940 <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (fifth(5))>
12941 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12949 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12952 myValue BERPDU ::= fifth
12960 import from TempA all;
12962 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12967 if (dec_BER_PDU('0A810105'O) == myValue)
12969 {setverdict(pass);} else {setverdict(fail);}
12974 Overall verdict: pass
12980 .*---------------------------------------------------------------------*
12981 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (fifth(5))
12982 .*---------------------------------------------------------------------*
12985 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (fifth(5))>
12986 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12994 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12997 myValue BERPDU ::= fifth
13005 import from TempA all;
13007 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13012 if (dec_BER_PDU('A0030A0105'O) == myValue)
13014 {setverdict(pass);} else {setverdict(fail);}
13019 Overall verdict: pass
13025 .*---------------------------------------------------------------------*
13026 :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (fifth(5))
13027 .*---------------------------------------------------------------------*
13030 <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (fifth(5))>
13031 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13039 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13042 myValue BERPDU ::= fifth
13050 import from TempA all;
13052 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13057 if (dec_BER_PDU('A0800A01050000'O) == myValue)
13059 {setverdict(pass);} else {setverdict(fail);}
13064 Overall verdict: pass
13070 .*---------------------------------------------------------------------*
13071 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (fifth(5))
13072 .*---------------------------------------------------------------------*
13075 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (fifth(5))>
13076 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13084 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13087 myValue BERPDU ::= fifth
13095 import from TempA all;
13097 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13102 if (dec_BER_PDU('A0040A810105'O) == myValue)
13104 {setverdict(pass);} else {setverdict(fail);}
13109 Overall verdict: pass
13115 .*---------------------------------------------------------------------*
13116 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (fifth(5))
13117 .*---------------------------------------------------------------------*
13120 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (fifth(5))>
13121 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13129 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13132 myValue BERPDU ::= fifth
13140 import from TempA all;
13142 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13147 if (dec_BER_PDU('A081040A810105'O) == myValue)
13149 {setverdict(pass);} else {setverdict(fail);}
13154 Overall verdict: pass
13160 .*---------------------------------------------------------------------*
13161 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (fifth(5))
13162 .*---------------------------------------------------------------------*
13165 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (fifth(5))>
13166 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13174 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13177 myValue BERPDU ::= fifth
13185 import from TempA all;
13187 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13192 if (dec_BER_PDU('9F580105'O) == myValue)
13194 {setverdict(pass);} else {setverdict(fail);}
13199 Overall verdict: pass
13205 .*---------------------------------------------------------------------*
13206 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (fifth(5))
13207 .*---------------------------------------------------------------------*
13210 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (fifth(5))>
13211 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13219 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13222 myValue BERPDU ::= fifth
13230 import from TempA all;
13232 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13237 if (dec_BER_PDU('9F58810105'O) == myValue)
13239 {setverdict(pass);} else {setverdict(fail);}
13244 Overall verdict: pass
13250 .*---------------------------------------------------------------------*
13251 :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (sixth)
13252 .*---------------------------------------------------------------------*
13255 <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (sixth)>
13256 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13264 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13267 myValue BERPDU ::= sixth
13275 import from TempA all;
13277 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13282 if (dec_BER_PDU('0A0106'O) == myValue)
13284 {setverdict(pass);} else {setverdict(fail);}
13289 Overall verdict: pass
13295 .*---------------------------------------------------------------------*
13296 :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (sixth)
13297 .*---------------------------------------------------------------------*
13300 <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (sixth)>
13301 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13309 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13312 myValue BERPDU ::= sixth
13320 import from TempA all;
13322 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13327 if (dec_BER_PDU('0A810106'O) == myValue)
13329 {setverdict(pass);} else {setverdict(fail);}
13334 Overall verdict: pass
13340 .*---------------------------------------------------------------------*
13341 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (sixth)
13342 .*---------------------------------------------------------------------*
13345 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (sixth)>
13346 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13354 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13357 myValue BERPDU ::= sixth
13365 import from TempA all;
13367 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13372 if (dec_BER_PDU('A0030A0106'O) == myValue)
13374 {setverdict(pass);} else {setverdict(fail);}
13379 Overall verdict: pass
13385 .*---------------------------------------------------------------------*
13386 :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (sixth)
13387 .*---------------------------------------------------------------------*
13390 <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (sixth)>
13391 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13399 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13402 myValue BERPDU ::= sixth
13410 import from TempA all;
13412 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13417 if (dec_BER_PDU('A0800A01060000'O) == myValue)
13419 {setverdict(pass);} else {setverdict(fail);}
13424 Overall verdict: pass
13430 .*---------------------------------------------------------------------*
13431 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (sixth)
13432 .*---------------------------------------------------------------------*
13435 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (sixth)>
13436 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13444 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13447 myValue BERPDU ::= sixth
13455 import from TempA all;
13457 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13462 if (dec_BER_PDU('A0040A810106'O) == myValue)
13464 {setverdict(pass);} else {setverdict(fail);}
13469 Overall verdict: pass
13475 .*---------------------------------------------------------------------*
13476 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (sixth)
13477 .*---------------------------------------------------------------------*
13480 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (sixth)>
13481 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13489 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13492 myValue BERPDU ::= sixth
13500 import from TempA all;
13502 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13507 if (dec_BER_PDU('A081040A810106'O) == myValue)
13509 {setverdict(pass);} else {setverdict(fail);}
13514 Overall verdict: pass
13520 .*---------------------------------------------------------------------*
13521 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (sixth)
13522 .*---------------------------------------------------------------------*
13525 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (sixth)>
13526 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13534 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13537 myValue BERPDU ::= sixth
13545 import from TempA all;
13547 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13552 if (dec_BER_PDU('9F580106'O) == myValue)
13554 {setverdict(pass);} else {setverdict(fail);}
13559 Overall verdict: pass
13565 .*---------------------------------------------------------------------*
13566 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (sixth)
13567 .*---------------------------------------------------------------------*
13570 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (sixth)>
13571 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13579 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13582 myValue BERPDU ::= sixth
13590 import from TempA all;
13592 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13597 if (dec_BER_PDU('9F58810106'O) == myValue)
13599 {setverdict(pass);} else {setverdict(fail);}
13604 Overall verdict: pass
13610 .*---------------------------------------------------------------------*
13611 :h3.CER + DER encoding of REAL, 0 (primitive)
13612 .*---------------------------------------------------------------------*
13615 <TC - CER + DER encoding of REAL, 0 (primitive)>
13630 import from TempA all;
13631 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13632 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13638 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13642 Overall verdict: pass
13648 .*---------------------------------------------------------------------*
13649 :h3.CER + DER encoding of REAL, 0.0 (primitive)
13650 .*---------------------------------------------------------------------*
13653 <TC - CER + DER encoding of REAL, 0.0 (primitive)>
13668 import from TempA all;
13669 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13670 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13676 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13680 Overall verdict: pass
13686 .*---------------------------------------------------------------------*
13687 :h3.CER + DER encoding of REAL, 0E0 (primitive)
13688 .*---------------------------------------------------------------------*
13691 <TC - CER + DER encoding of REAL, 0E0 (primitive)>
13706 import from TempA all;
13707 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13708 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13714 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13718 Overall verdict: pass
13724 .*---------------------------------------------------------------------*
13725 :h3.CER + DER encoding of REAL, 0.0E0 (primitive)
13726 .*---------------------------------------------------------------------*
13729 <TC - CER + DER encoding of REAL, 0.0E0 (primitive)>
13744 import from TempA all;
13745 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13746 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13752 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13756 Overall verdict: pass
13762 .*---------------------------------------------------------------------*
13763 :h3.CER + DER encoding of REAL, 0e0 (primitive)
13764 .*---------------------------------------------------------------------*
13767 <TC - CER + DER encoding of REAL, 0e0 (primitive)>
13782 import from TempA all;
13783 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13784 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13790 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13794 Overall verdict: pass
13800 .*---------------------------------------------------------------------*
13801 :h3.CER + DER encoding of REAL, 0.0e0 (primitive)
13802 .*---------------------------------------------------------------------*
13805 <TC - CER + DER encoding of REAL, 0.0e0 (primitive)>
13820 import from TempA all;
13821 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13822 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13828 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13832 Overall verdict: pass
13838 .*---------------------------------------------------------------------*
13839 :h3.CER + DER encoding of REAL, 0E+0 (primitive)
13840 .*---------------------------------------------------------------------*
13843 <TC - CER + DER encoding of REAL, 0E+0 (primitive)>
13858 import from TempA all;
13859 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13860 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13866 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13870 Overall verdict: pass
13876 .*---------------------------------------------------------------------*
13877 :h3.CER + DER encoding of REAL, 0.0E+0 (primitive)
13878 .*---------------------------------------------------------------------*
13881 <TC - CER + DER encoding of REAL, 0.0E+0 (primitive)>
13890 b BERPDU ::= 0.0E+0
13896 import from TempA all;
13897 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13898 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13904 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13908 Overall verdict: pass
13914 .*---------------------------------------------------------------------*
13915 :h3.CER + DER encoding of REAL, 0e+0 (primitive)
13916 .*---------------------------------------------------------------------*
13919 <TC - CER + DER encoding of REAL, 0e+0 (primitive)>
13934 import from TempA all;
13935 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13936 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13942 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13946 Overall verdict: pass
13952 .*---------------------------------------------------------------------*
13953 :h3.CER + DER encoding of REAL, 0.0e+0 (primitive)
13954 .*---------------------------------------------------------------------*
13957 <TC - CER + DER encoding of REAL, 0.0e+0 (primitive)>
13966 b BERPDU ::= 0.0e+0
13972 import from TempA all;
13973 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13974 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13980 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13984 Overall verdict: pass
13990 .*---------------------------------------------------------------------*
13991 :h3.CER + DER encoding of REAL, 0E-0 (primitive)
13992 .*---------------------------------------------------------------------*
13995 <TC - CER + DER encoding of REAL, 0E-0 (primitive)>
14010 import from TempA all;
14011 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14012 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14018 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
14022 Overall verdict: pass
14028 .*---------------------------------------------------------------------*
14029 :h3.CER + DER encoding of REAL, 0.0E-0 (primitive)
14030 .*---------------------------------------------------------------------*
14033 <TC - CER + DER encoding of REAL, 0.0E-0 (primitive)>
14042 b BERPDU ::= 0.0E-0
14048 import from TempA all;
14049 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14050 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14056 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
14060 Overall verdict: pass
14066 .*---------------------------------------------------------------------*
14067 :h3.CER + DER encoding of REAL, 0e-0 (primitive)
14068 .*---------------------------------------------------------------------*
14071 <TC - CER + DER encoding of REAL, 0e-0 (primitive)>
14086 import from TempA all;
14087 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14088 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14094 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
14098 Overall verdict: pass
14104 .*---------------------------------------------------------------------*
14105 :h3.CER + DER encoding of REAL, 0.0e-0 (primitive)
14106 .*---------------------------------------------------------------------*
14109 <TC - CER + DER encoding of REAL, 0.0e-0 (primitive)>
14118 b BERPDU ::= 0.0e-0
14124 import from TempA all;
14125 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14126 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14132 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
14136 Overall verdict: pass
14142 .*---------------------------------------------------------------------*
14143 :h3.CER + DER encoding of REAL, 1 (primitive)
14144 .*---------------------------------------------------------------------*
14147 <TC - CER + DER encoding of REAL, 1 (primitive)>
14162 import from TempA all;
14163 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14164 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14170 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14174 Overall verdict: pass
14180 .*---------------------------------------------------------------------*
14181 :h3.CER + DER encoding of REAL, 1e0 (primitive)
14182 .*---------------------------------------------------------------------*
14185 <TC - CER + DER encoding of REAL, 1e0 (primitive)>
14200 import from TempA all;
14201 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14202 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14208 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14212 Overall verdict: pass
14218 .*---------------------------------------------------------------------*
14219 :h3.CER + DER encoding of REAL, 1E0 (primitive)
14220 .*---------------------------------------------------------------------*
14223 <TC - CER + DER encoding of REAL, 1E0 (primitive)>
14238 import from TempA all;
14239 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14240 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14246 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14250 Overall verdict: pass
14256 .*---------------------------------------------------------------------*
14257 :h3.CER + DER encoding of REAL, 1.0e0 (primitive)
14258 .*---------------------------------------------------------------------*
14261 <TC - CER + DER encoding of REAL, 1.0e0 (primitive)>
14276 import from TempA all;
14277 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14278 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14284 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14288 Overall verdict: pass
14294 .*---------------------------------------------------------------------*
14295 :h3.CER + DER encoding of REAL, 1.0E0 (primitive)
14296 .*---------------------------------------------------------------------*
14299 <TC - CER + DER encoding of REAL, 1.0E0 (primitive)>
14314 import from TempA all;
14315 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14316 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14322 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14326 Overall verdict: pass
14332 .*---------------------------------------------------------------------*
14333 :h3.CER + DER encoding of REAL, 1e+0 (primitive)
14334 .*---------------------------------------------------------------------*
14337 <TC - CER + DER encoding of REAL, 1e+0 (primitive)>
14352 import from TempA all;
14353 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14354 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14360 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14364 Overall verdict: pass
14370 .*---------------------------------------------------------------------*
14371 :h3.CER + DER encoding of REAL, 1E+0 (primitive)
14372 .*---------------------------------------------------------------------*
14375 <TC - CER + DER encoding of REAL, 1E+0 (primitive)>
14390 import from TempA all;
14391 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14392 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14398 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14402 Overall verdict: pass
14408 .*---------------------------------------------------------------------*
14409 :h3.CER + DER encoding of REAL, 1.0e+0 (primitive)
14410 .*---------------------------------------------------------------------*
14413 <TC - CER + DER encoding of REAL, 1.0e+0 (primitive)>
14422 b BERPDU ::= 1.0e+0
14428 import from TempA all;
14429 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14430 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14436 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14440 Overall verdict: pass
14446 .*---------------------------------------------------------------------*
14447 :h3.CER + DER encoding of REAL, 1.0E+0 (primitive)
14448 .*---------------------------------------------------------------------*
14451 <TC - CER + DER encoding of REAL, 1.0E+0 (primitive)>
14460 b BERPDU ::= 1.0E+0
14466 import from TempA all;
14467 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14468 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14474 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14478 Overall verdict: pass
14484 .*---------------------------------------------------------------------*
14485 :h3.CER + DER encoding of REAL, 1e-0 (primitive)
14486 .*---------------------------------------------------------------------*
14489 <TC - CER + DER encoding of REAL, 1e-0 (primitive)>
14504 import from TempA all;
14505 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14506 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14512 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14516 Overall verdict: pass
14522 .*---------------------------------------------------------------------*
14523 :h3.CER + DER encoding of REAL, 1E-0 (primitive)
14524 .*---------------------------------------------------------------------*
14527 <TC - CER + DER encoding of REAL, 1E-0 (primitive)>
14542 import from TempA all;
14543 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14544 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14550 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14554 Overall verdict: pass
14560 .*---------------------------------------------------------------------*
14561 :h3.CER + DER encoding of REAL, 1.0e-0 (primitive)
14562 .*---------------------------------------------------------------------*
14565 <TC - CER + DER encoding of REAL, 1.0e-0 (primitive)>
14574 b BERPDU ::= 1.0e-0
14580 import from TempA all;
14581 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14582 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14588 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14592 Overall verdict: pass
14598 .*---------------------------------------------------------------------*
14599 :h3.CER + DER encoding of REAL, 1.0E-0 (primitive)
14600 .*---------------------------------------------------------------------*
14603 <TC - CER + DER encoding of REAL, 1.0E-0 (primitive)>
14612 b BERPDU ::= 1.0E-0
14618 import from TempA all;
14619 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14620 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14626 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14630 Overall verdict: pass
14636 .*---------------------------------------------------------------------*
14637 :h3.CER + DER encoding of REAL, 2 (primitive)
14638 .*---------------------------------------------------------------------*
14641 <TC - CER + DER encoding of REAL, 2 (primitive)>
14656 import from TempA all;
14657 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14658 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14664 if ((enc_DER_PDU(b) == '090603322E452B30'O)and(enc_CER_PDU(b) == '090603322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14668 Overall verdict: pass
14674 .*---------------------------------------------------------------------*
14675 :h3.CER + DER encoding of REAL, 2.0 (primitive)
14676 .*---------------------------------------------------------------------*
14679 <TC - CER + DER encoding of REAL, 2.0 (primitive)>
14694 import from TempA all;
14695 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14696 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14702 if ((enc_DER_PDU(b) == '090603322E452B30'O)and(enc_CER_PDU(b) == '090603322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14706 Overall verdict: pass
14712 .*---------------------------------------------------------------------*
14713 :h3.CER + DER encoding of REAL, -1 (primitive)
14714 .*---------------------------------------------------------------------*
14717 <TC - CER + DER encoding of REAL, -1 (primitive)>
14732 import from TempA all;
14733 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14734 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14740 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14744 Overall verdict: pass
14750 .*---------------------------------------------------------------------*
14751 :h3.CER + DER encoding of REAL, -1e0 (primitive)
14752 .*---------------------------------------------------------------------*
14755 <TC - CER + DER encoding of REAL, -1e0 (primitive)>
14770 import from TempA all;
14771 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14772 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14778 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14782 Overall verdict: pass
14788 .*---------------------------------------------------------------------*
14789 :h3.CER + DER encoding of REAL, -1E0 (primitive)
14790 .*---------------------------------------------------------------------*
14793 <TC - CER + DER encoding of REAL, -1E0 (primitive)>
14808 import from TempA all;
14809 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14810 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14816 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14820 Overall verdict: pass
14826 .*---------------------------------------------------------------------*
14827 :h3.CER + DER encoding of REAL, -1.0e0 (primitive)
14828 .*---------------------------------------------------------------------*
14831 <TC - CER + DER encoding of REAL, -1.0e0 (primitive)>
14840 b BERPDU ::= -1.0e0
14846 import from TempA all;
14847 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14848 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14854 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14858 Overall verdict: pass
14864 .*---------------------------------------------------------------------*
14865 :h3.CER + DER encoding of REAL, -1.0E0 (primitive)
14866 .*---------------------------------------------------------------------*
14869 <TC - CER + DER encoding of REAL, -1.0E0 (primitive)>
14878 b BERPDU ::= -1.0E0
14884 import from TempA all;
14885 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14886 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14892 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14896 Overall verdict: pass
14902 .*---------------------------------------------------------------------*
14903 :h3.CER + DER encoding of REAL, -1e+0 (primitive)
14904 .*---------------------------------------------------------------------*
14907 <TC - CER + DER encoding of REAL, -1e+0 (primitive)>
14922 import from TempA all;
14923 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14924 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14930 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14934 Overall verdict: pass
14940 .*---------------------------------------------------------------------*
14941 :h3.CER + DER encoding of REAL, -1E+0 (primitive)
14942 .*---------------------------------------------------------------------*
14945 <TC - CER + DER encoding of REAL, -1E+0 (primitive)>
14960 import from TempA all;
14961 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14962 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14968 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14972 Overall verdict: pass
14978 .*---------------------------------------------------------------------*
14979 :h3.CER + DER encoding of REAL, -1.0e+0 (primitive)
14980 .*---------------------------------------------------------------------*
14983 <TC - CER + DER encoding of REAL, -1.0e+0 (primitive)>
14992 b BERPDU ::= -1.0e+0
14998 import from TempA all;
14999 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15000 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15006 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15010 Overall verdict: pass
15016 .*---------------------------------------------------------------------*
15017 :h3.CER + DER encoding of REAL, -1.0E+0 (primitive)
15018 .*---------------------------------------------------------------------*
15021 <TC - CER + DER encoding of REAL, -1.0E+0 (primitive)>
15030 b BERPDU ::= -1.0E+0
15036 import from TempA all;
15037 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15038 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15044 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15048 Overall verdict: pass
15054 .*---------------------------------------------------------------------*
15055 :h3.CER + DER encoding of REAL, -1e-0 (primitive)
15056 .*---------------------------------------------------------------------*
15059 <TC - CER + DER encoding of REAL, -1e-0 (primitive)>
15074 import from TempA all;
15075 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15076 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15082 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15086 Overall verdict: pass
15092 .*---------------------------------------------------------------------*
15093 :h3.CER + DER encoding of REAL, -1E-0 (primitive)
15094 .*---------------------------------------------------------------------*
15097 <TC - CER + DER encoding of REAL, -1E-0 (primitive)>
15112 import from TempA all;
15113 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15114 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15120 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15124 Overall verdict: pass
15130 .*---------------------------------------------------------------------*
15131 :h3.CER + DER encoding of REAL, -1.0e-0 (primitive)
15132 .*---------------------------------------------------------------------*
15135 <TC - CER + DER encoding of REAL, -1.0e-0 (primitive)>
15144 b BERPDU ::= -1.0e-0
15150 import from TempA all;
15151 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15152 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15158 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15162 Overall verdict: pass
15168 .*---------------------------------------------------------------------*
15169 :h3.CER + DER encoding of REAL, -1.0E-0 (primitive)
15170 .*---------------------------------------------------------------------*
15173 <TC - CER + DER encoding of REAL, -1.0E-0 (primitive)>
15182 b BERPDU ::= -1.0E-0
15188 import from TempA all;
15189 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15190 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15196 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15200 Overall verdict: pass
15206 .*---------------------------------------------------------------------*
15207 :h3.CER + DER encoding of REAL, -1.0 (primitive)
15208 .*---------------------------------------------------------------------*
15211 <TC - CER + DER encoding of REAL, -1.0 (primitive)>
15226 import from TempA all;
15227 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15228 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15234 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15238 Overall verdict: pass
15244 .*---------------------------------------------------------------------*
15245 :h3.CER + DER encoding of REAL, 1.000 (primitive)
15246 .*---------------------------------------------------------------------*
15249 <TC - CER + DER encoding of REAL, 1.000 (primitive)>
15264 import from TempA all;
15265 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15266 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15272 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15276 Overall verdict: pass
15282 .*---------------------------------------------------------------------*
15283 :h3.CER + DER encoding of REAL, -1.000 (primitive)
15284 .*---------------------------------------------------------------------*
15287 <TC - CER + DER encoding of REAL, -1.000 (primitive)>
15296 b BERPDU ::= -1.000
15302 import from TempA all;
15303 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15304 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15310 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15314 Overall verdict: pass
15320 .*---------------------------------------------------------------------*
15321 :h3.CER + DER encoding of REAL, 12 (primitive)
15322 .*---------------------------------------------------------------------*
15325 <TC - CER + DER encoding of REAL, 12 (primitive)>
15340 import from TempA all;
15341 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15342 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15348 if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15352 Overall verdict: pass
15358 .*---------------------------------------------------------------------*
15359 :h3.CER + DER encoding of REAL, 12.0 (primitive)
15360 .*---------------------------------------------------------------------*
15363 <TC - CER + DER encoding of REAL, 12.0 (primitive)>
15378 import from TempA all;
15379 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15380 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15386 if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15390 Overall verdict: pass
15396 .*---------------------------------------------------------------------*
15397 :h3.CER + DER encoding of REAL, 12.0E0 (primitive)
15398 .*---------------------------------------------------------------------*
15401 <TC - CER + DER encoding of REAL, 12.0E0 (primitive)>
15410 b BERPDU ::= 12.0E0
15416 import from TempA all;
15417 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15418 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15424 if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15428 Overall verdict: pass
15434 .*---------------------------------------------------------------------*
15435 :h3.CER + DER encoding of REAL, 1.2E1 (primitive)
15436 .*---------------------------------------------------------------------*
15439 <TC - CER + DER encoding of REAL, 1.2E1 (primitive)>
15454 import from TempA all;
15455 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15456 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15462 if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15466 Overall verdict: pass
15472 .*---------------------------------------------------------------------*
15473 :h3.CER + DER encoding of REAL, 0.12E2 (primitive)
15474 .*---------------------------------------------------------------------*
15477 <TC - CER + DER encoding of REAL, 0.12E2 (primitive)>
15486 b BERPDU ::= 0.12E2
15492 import from TempA all;
15493 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15494 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15500 if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15504 Overall verdict: pass
15510 .*---------------------------------------------------------------------*
15511 :h3.CER + DER encoding of REAL, 1.2E+1 (primitive)
15512 .*---------------------------------------------------------------------*
15515 <TC - CER + DER encoding of REAL, 1.2E+1 (primitive)>
15530 import from TempA all;
15531 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15532 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15538 if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15542 Overall verdict: pass
15548 .*---------------------------------------------------------------------*
15549 :h3.CER + DER encoding of REAL, 0.12E+2 (primitive)
15550 .*---------------------------------------------------------------------*
15553 <TC - CER + DER encoding of REAL, 0.12E+2 (primitive)>
15562 b BERPDU ::= 0.12E2
15568 import from TempA all;
15569 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15570 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15576 if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15580 Overall verdict: pass
15586 .*---------------------------------------------------------------------*
15587 :h3.CER + DER encoding of REAL, 0.34 (primitive)
15588 .*---------------------------------------------------------------------*
15591 <TC - CER + DER encoding of REAL, 0.34 (primitive)>
15606 import from TempA all;
15607 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15608 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15614 if ((enc_DER_PDU(b) == '09070333342E452D32'O)and(enc_CER_PDU(b) == '09070333342E452D32'O)) {setverdict(pass);} else {setverdict(fail);}
15618 Overall verdict: pass
15624 .*---------------------------------------------------------------------*
15625 :h3.CER + DER encoding of REAL, 0.344 (primitive)
15626 .*---------------------------------------------------------------------*
15629 <TC - CER + DER encoding of REAL, 0.344 (primitive)>
15644 import from TempA all;
15645 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15646 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15652 if ((enc_DER_PDU(b) == '0908033334342E452D33'O)and(enc_CER_PDU(b) == '0908033334342E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
15656 Overall verdict: pass
15662 .*---------------------------------------------------------------------*
15663 :h3.CER + DER encoding of REAL, 0.345 (primitive)
15664 .*---------------------------------------------------------------------*
15667 <TC - CER + DER encoding of REAL, 0.345 (primitive)>
15682 import from TempA all;
15683 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15684 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15690 if ((enc_DER_PDU(b) == '0908033334352E452D33'O)and(enc_CER_PDU(b) == '0908033334352E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
15694 Overall verdict: pass
15700 .*---------------------------------------------------------------------*
15701 :h3.CER + DER encoding of REAL, 0.034 (primitive)
15702 .*---------------------------------------------------------------------*
15705 <TC - CER + DER encoding of REAL, 0.034 (primitive)>
15720 import from TempA all;
15721 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15722 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15728 if ((enc_DER_PDU(b) == '09070333342E452D33'O)and(enc_CER_PDU(b) == '09070333342E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
15732 Overall verdict: pass
15738 .*---------------------------------------------------------------------*
15739 :h3.CER + DER encoding of REAL, 0.0034 (primitive)
15740 .*---------------------------------------------------------------------*
15743 <TC - CER + DER encoding of REAL, 0.0034 (primitive)>
15752 b BERPDU ::= 0.0034
15758 import from TempA all;
15759 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15760 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15766 if ((enc_DER_PDU(b) == '09070333342E452D34'O)and(enc_CER_PDU(b) == '09070333342E452D34'O)) {setverdict(pass);} else {setverdict(fail);}
15770 Overall verdict: pass
15776 .*---------------------------------------------------------------------*
15777 :h3.CER + DER encoding of REAL, 0.304 (primitive)
15778 .*---------------------------------------------------------------------*
15781 <TC - CER + DER encoding of REAL, 0.304 (primitive)>
15796 import from TempA all;
15797 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15798 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15804 if ((enc_DER_PDU(b) == '0908033330342E452D33'O)and(enc_CER_PDU(b) == '0908033330342E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
15808 Overall verdict: pass
15814 .*---------------------------------------------------------------------*
15815 :h3.CER + DER encoding of REAL, 0.1234567890 (primitive)
15816 .*---------------------------------------------------------------------*
15819 <TC - CER + DER encoding of REAL, 0.1234567890 (primitive)>
15828 b BERPDU ::= 0.1234567890
15834 import from TempA all;
15835 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15836 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15842 if ((enc_DER_PDU(b) == '090E033132333435363738392E452D39'O)and(enc_CER_PDU(b) == '090E033132333435363738392E452D39'O)) {setverdict(pass);} else {setverdict(fail);}
15846 Overall verdict: pass
15852 .*---------------------------------------------------------------------*
15853 :h3.CER + DER encoding of REAL, 0.123456789 (primitive)
15854 .*---------------------------------------------------------------------*
15857 <TC - CER + DER encoding of REAL, 0.123456789 (primitive)>
15866 b BERPDU ::= 0.123456789
15872 import from TempA all;
15873 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15874 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15880 if ((enc_DER_PDU(b) == '090E033132333435363738392E452D39'O)and(enc_CER_PDU(b) == '090E033132333435363738392E452D39'O)) {setverdict(pass);} else {setverdict(fail);}
15884 Overall verdict: pass
15890 .*---------------------------------------------------------------------*
15891 :h3.CER + DER encoding of REAL, 0.0123456789 (primitive)
15892 .*---------------------------------------------------------------------*
15895 <TC - CER + DER encoding of REAL, 0.0123456789 (primitive)>
15904 b BERPDU ::= 0.0123456789
15910 import from TempA all;
15911 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15912 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15918 if ((enc_DER_PDU(b) == '090F033132333435363738392E452D3130'O)and(enc_CER_PDU(b) == '090F033132333435363738392E452D3130'O)) {setverdict(pass);} else {setverdict(fail);}
15922 Overall verdict: pass
15928 .*---------------------------------------------------------------------*
15929 :h3.CER + DER encoding of REAL, 123456789.0 (primitive)
15930 .*---------------------------------------------------------------------*
15933 <TC - CER + DER encoding of REAL, 123456789.0 (primitive)>
15942 b BERPDU ::= 123456789.0
15948 import from TempA all;
15949 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15950 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15956 if ((enc_DER_PDU(b) == '090E033132333435363738392E452B30'O)and(enc_CER_PDU(b) == '090E033132333435363738392E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15960 Overall verdict: pass
15966 .*---------------------------------------------------------------------*
15967 :h3.CER + DER encoding of REAL, 123456789 (primitive)
15968 .*---------------------------------------------------------------------*
15971 <TC - CER + DER encoding of REAL, 123456789 (primitive)>
15980 b BERPDU ::= 123456789
15986 import from TempA all;
15987 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15988 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15994 if ((enc_DER_PDU(b) == '090E033132333435363738392E452B30'O)and(enc_CER_PDU(b) == '090E033132333435363738392E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15998 Overall verdict: pass
16004 .*---------------------------------------------------------------------*
16005 :h3.CER + DER encoding of REAL, 1234567890 (primitive)
16006 .*---------------------------------------------------------------------*
16009 <TC - CER + DER encoding of REAL, 1234567890 (primitive)>
16018 b BERPDU ::= 1234567890
16024 import from TempA all;
16025 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16026 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16032 if ((enc_DER_PDU(b) == '090D033132333435363738392E4531'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);}
16036 Overall verdict: pass
16042 .*---------------------------------------------------------------------*
16043 :h3.CER + DER encoding of REAL, 1234567890.0 (primitive)
16044 .*---------------------------------------------------------------------*
16047 <TC - CER + DER encoding of REAL, 1234567890.0 (primitive)>
16056 b BERPDU ::= 1234567890.0
16062 import from TempA all;
16063 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16064 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16070 if ((enc_DER_PDU(b) == '090D033132333435363738392E4531'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);}
16074 Overall verdict: pass
16080 .*---------------------------------------------------------------------*
16081 :h3.CER + DER encoding of REAL, 1234567890.00 (primitive)
16082 .*---------------------------------------------------------------------*
16085 <TC - CER + DER encoding of REAL, 1234567890.00 (primitive)>
16094 b BERPDU ::= 1234567890.00
16100 import from TempA all;
16101 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16102 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16108 if ((enc_DER_PDU(b) == '090D033132333435363738392E4531'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);}
16112 Overall verdict: pass
16118 .*---------------------------------------------------------------------*
16119 :h3.CER + DER encoding of REAL, 12345678900.0 (primitive)
16120 .*---------------------------------------------------------------------*
16123 <TC - CER + DER encoding of REAL, 12345678900.0 (primitive)>
16132 b BERPDU ::= 12345678900.0
16138 import from TempA all;
16139 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16140 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16146 if ((enc_DER_PDU(b) == '090D033132333435363738392E4532'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);}
16150 Overall verdict: pass
16156 .*---------------------------------------------------------------------*
16157 :h3.CER + DER encoding of REAL, 12345678900.0 (primitive)
16158 .*---------------------------------------------------------------------*
16161 <TC - CER + DER encoding of REAL, 12345678900.0 (primitive)>
16170 b BERPDU ::=12345678900.0
16176 import from TempA all;
16177 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16178 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16184 if ((enc_DER_PDU(b) == '090D033132333435363738392E4532'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);}
16188 Overall verdict: pass
16194 .*---------------------------------------------------------------------*
16195 :h3.CER + DER encoding of REAL, 12345678900.00 (primitive)
16196 .*---------------------------------------------------------------------*
16199 <TC - CER + DER encoding of REAL, 12345678900.00 (primitive)>
16208 b BERPDU ::= 12345678900.00
16214 import from TempA all;
16215 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16216 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16222 if ((enc_DER_PDU(b) == '090D033132333435363738392E4532'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);}
16226 Overall verdict: pass
16232 .*---------------------------------------------------------------------*
16233 :h3.CER + DER encoding of REAL, -12 (primitive)
16234 .*---------------------------------------------------------------------*
16237 <TC - CER + DER encoding of REAL, -12 (primitive)>
16252 import from TempA all;
16253 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16254 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16260 if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16264 Overall verdict: pass
16270 .*---------------------------------------------------------------------*
16271 :h3.CER + DER encoding of REAL, -12.0 (primitive)
16272 .*---------------------------------------------------------------------*
16275 <TC - CER + DER encoding of REAL, -12.0 (primitive)>
16290 import from TempA all;
16291 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16292 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16298 if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16302 Overall verdict: pass
16308 .*---------------------------------------------------------------------*
16309 :h3.CER + DER encoding of REAL, -12.0E0 (primitive)
16310 .*---------------------------------------------------------------------*
16313 <TC - CER + DER encoding of REAL, -12.0E0 (primitive)>
16322 b BERPDU ::= -12.0E0
16328 import from TempA all;
16329 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16330 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16336 if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16340 Overall verdict: pass
16346 .*---------------------------------------------------------------------*
16347 :h3.CER + DER encoding of REAL, -1.2E1 (primitive)
16348 .*---------------------------------------------------------------------*
16351 <TC - CER + DER encoding of REAL, -1.2E1 (primitive)>
16360 b BERPDU ::= -1.2E1
16366 import from TempA all;
16367 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16368 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16374 if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16378 Overall verdict: pass
16384 .*---------------------------------------------------------------------*
16385 :h3.CER + DER encoding of REAL, -0.12E2 (primitive)
16386 .*---------------------------------------------------------------------*
16389 <TC - CER + DER encoding of REAL, -0.12E2 (primitive)>
16398 b BERPDU ::= -0.12E2
16404 import from TempA all;
16405 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16406 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16412 if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16416 Overall verdict: pass
16422 .*---------------------------------------------------------------------*
16423 :h3.CER + DER encoding of REAL, -1.2E+1 (primitive)
16424 .*---------------------------------------------------------------------*
16427 <TC - CER + DER encoding of REAL, -1.2E+1 (primitive)>
16436 b BERPDU ::= -1.2E1
16442 import from TempA all;
16443 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16444 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16450 if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16454 Overall verdict: pass
16460 .*---------------------------------------------------------------------*
16461 :h3.CER + DER encoding of REAL, -0.12E+2 (primitive)
16462 .*---------------------------------------------------------------------*
16465 <TC - CER + DER encoding of REAL, -0.12E+2 (primitive)>
16474 b BERPDU ::= -0.12E2
16480 import from TempA all;
16481 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16482 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16488 if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16492 Overall verdict: pass
16498 .*---------------------------------------------------------------------*
16499 :h3.CER + DER encoding of REAL, -0.34 (primitive)
16500 .*---------------------------------------------------------------------*
16503 <TC - CER + DER encoding of REAL, -0.34 (primitive)>
16518 import from TempA all;
16519 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16520 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16526 if ((enc_DER_PDU(b) == '0908032D33342E452D32'O)and(enc_CER_PDU(b) == '0908032D33342E452D32'O)) {setverdict(pass);} else {setverdict(fail);}
16530 Overall verdict: pass
16536 .*---------------------------------------------------------------------*
16537 :h3.CER + DER encoding of REAL, -0.344 (primitive)
16538 .*---------------------------------------------------------------------*
16541 <TC - CER + DER encoding of REAL, -0.344 (primitive)>
16550 b BERPDU ::= -0.344
16556 import from TempA all;
16557 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16558 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16564 if ((enc_DER_PDU(b) == '0909032D3334342E452D33'O)and(enc_CER_PDU(b) == '0909032D3334342E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
16568 Overall verdict: pass
16574 .*---------------------------------------------------------------------*
16575 :h3.CER + DER encoding of REAL, -0.345 (primitive)
16576 .*---------------------------------------------------------------------*
16579 <TC - CER + DER encoding of REAL, -0.345 (primitive)>
16588 b BERPDU ::= -0.345
16594 import from TempA all;
16595 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16596 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16602 if ((enc_DER_PDU(b) == '0909032D3334352E452D33'O)and(enc_CER_PDU(b) == '0909032D3334352E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
16606 Overall verdict: pass
16612 .*---------------------------------------------------------------------*
16613 :h3.CER + DER encoding of REAL, -0.034 (primitive)
16614 .*---------------------------------------------------------------------*
16617 <TC - CER + DER encoding of REAL, -0.034 (primitive)>
16626 b BERPDU ::= -0.034
16632 import from TempA all;
16633 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16634 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16640 if ((enc_DER_PDU(b) == '0908032D33342E452D33'O)and(enc_CER_PDU(b) == '0908032D33342E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
16644 Overall verdict: pass
16650 .*---------------------------------------------------------------------*
16651 :h3.CER + DER encoding of REAL, -0.0034 (primitive)
16652 .*---------------------------------------------------------------------*
16655 <TC - CER + DER encoding of REAL, -0.0034 (primitive)>
16664 b BERPDU ::= -0.0034
16670 import from TempA all;
16671 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16672 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16678 if ((enc_DER_PDU(b) == '0908032D33342E452D34'O)and(enc_CER_PDU(b) == '0908032D33342E452D34'O)) {setverdict(pass);} else {setverdict(fail);}
16682 Overall verdict: pass
16688 .*---------------------------------------------------------------------*
16689 :h3.CER + DER encoding of REAL, -0.304 (primitive)
16690 .*---------------------------------------------------------------------*
16693 <TC - CER + DER encoding of REAL, -0.304 (primitive)>
16702 b BERPDU ::= -0.304
16708 import from TempA all;
16709 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16710 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16716 if ((enc_DER_PDU(b) == '0909032D3330342E452D33'O)and(enc_CER_PDU(b) == '0909032D3330342E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
16720 Overall verdict: pass
16726 .*---------------------------------------------------------------------*
16727 :h3.CER + DER encoding of REAL, -0.1234567890 (primitive)
16728 .*---------------------------------------------------------------------*
16731 <TC - CER + DER encoding of REAL, -0.1234567890 (primitive)>
16740 b BERPDU ::= -0.1234567890
16746 import from TempA all;
16747 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16748 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16754 if ((enc_DER_PDU(b) == '090F032D3132333435363738392E452D39'O)and(enc_CER_PDU(b) == '090F032D3132333435363738392E452D39'O)) {setverdict(pass);} else {setverdict(fail);}
16758 Overall verdict: pass
16764 .*---------------------------------------------------------------------*
16765 :h3.CER + DER encoding of REAL, -0.123456789 (primitive)
16766 .*---------------------------------------------------------------------*
16769 <TC - CER + DER encoding of REAL, -0.123456789 (primitive)>
16778 b BERPDU ::= -0.123456789
16784 import from TempA all;
16785 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16786 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16792 if ((enc_DER_PDU(b) == '090F032D3132333435363738392E452D39'O)and(enc_CER_PDU(b) == '090F032D3132333435363738392E452D39'O)) {setverdict(pass);} else {setverdict(fail);}
16796 Overall verdict: pass
16802 .*---------------------------------------------------------------------*
16803 :h3.CER + DER encoding of REAL, -0.0123456789 (primitive)
16804 .*---------------------------------------------------------------------*
16807 <TC - CER + DER encoding of REAL, -0.0123456789 (primitive)>
16816 b BERPDU ::= -0.0123456789
16822 import from TempA all;
16823 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16824 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16830 if ((enc_DER_PDU(b) == '0910032D3132333435363738392E452D3130'O)and(enc_CER_PDU(b) == '0910032D3132333435363738392E452D3130'O)) {setverdict(pass);} else {setverdict(fail);}
16834 Overall verdict: pass
16840 .*---------------------------------------------------------------------*
16841 :h3.CER + DER encoding of REAL, -123456789.0 (primitive)
16842 .*---------------------------------------------------------------------*
16845 <TC - CER + DER encoding of REAL, -123456789.0 (primitive)>
16854 b BERPDU ::= -123456789.0
16860 import from TempA all;
16861 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16862 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16868 if ((enc_DER_PDU(b) == '090F032D3132333435363738392E452B30'O)and(enc_CER_PDU(b) == '090F032D3132333435363738392E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16872 Overall verdict: pass
16878 .*---------------------------------------------------------------------*
16879 :h3.CER + DER encoding of REAL, -123456789 (primitive)
16880 .*---------------------------------------------------------------------*
16883 <TC - CER + DER encoding of REAL, -123456789 (primitive)>
16892 b BERPDU ::= -123456789
16898 import from TempA all;
16899 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16900 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16906 if ((enc_DER_PDU(b) == '090F032D3132333435363738392E452B30'O)and(enc_CER_PDU(b) == '090F032D3132333435363738392E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16910 Overall verdict: pass
16916 .*---------------------------------------------------------------------*
16917 :h3.CER + DER encoding of REAL, -1234567890 (primitive)
16918 .*---------------------------------------------------------------------*
16921 <TC - CER + DER encoding of REAL, -1234567890 (primitive)>
16930 b BERPDU ::= -1234567890
16936 import from TempA all;
16937 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16938 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16944 if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4531'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);}
16948 Overall verdict: pass
16954 .*---------------------------------------------------------------------*
16955 :h3.CER + DER encoding of REAL, -1234567890.0 (primitive)
16956 .*---------------------------------------------------------------------*
16959 <TC - CER + DER encoding of REAL, -1234567890.0 (primitive)>
16968 b BERPDU ::= -1234567890.0
16974 import from TempA all;
16975 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16976 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16982 if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4531'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);}
16986 Overall verdict: pass
16992 .*---------------------------------------------------------------------*
16993 :h3.CER + DER encoding of REAL, -1234567890.00 (primitive)
16994 .*---------------------------------------------------------------------*
16997 <TC - CER + DER encoding of REAL, -1234567890.00 (primitive)>
17006 b BERPDU ::= -1234567890.00
17012 import from TempA all;
17013 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17014 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17020 if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4531'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);}
17024 Overall verdict: pass
17030 .*---------------------------------------------------------------------*
17031 :h3.CER + DER encoding of REAL, -12345678900.0 (primitive)
17032 .*---------------------------------------------------------------------*
17035 <TC - CER + DER encoding of REAL, -12345678900.0 (primitive)>
17044 b BERPDU ::= -12345678900.0
17050 import from TempA all;
17051 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17052 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17058 if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4532'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);}
17062 Overall verdict: pass
17068 .*---------------------------------------------------------------------*
17069 :h3.CER + DER encoding of REAL, -12345678900.0 (primitive)
17070 .*---------------------------------------------------------------------*
17073 <TC - CER + DER encoding of REAL, -12345678900.0 (primitive)>
17082 b BERPDU ::= -12345678900.0
17088 import from TempA all;
17089 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17090 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17096 if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4532'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);}
17100 Overall verdict: pass
17106 .*---------------------------------------------------------------------*
17107 :h3.CER + DER encoding of REAL, -12345678900.00 (primitive)
17108 .*---------------------------------------------------------------------*
17111 <TC - CER + DER encoding of REAL, -12345678900.00 (primitive)>
17120 b BERPDU ::= -12345678900.00
17126 import from TempA all;
17127 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17128 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17134 if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4532'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);}
17138 Overall verdict: pass
17144 .*---------------------------------------------------------------------*
17145 :h3.CER + DER encoding of REAL, PLUS-INFINITY (primitive)
17146 .*---------------------------------------------------------------------*
17149 <TC - CER + DER encoding of REAL, PLUS-INFINITY (primitive)>
17158 b BERPDU ::= PLUS-INFINITY
17164 import from TempA all;
17165 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17166 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17172 if ((enc_DER_PDU(b) == '090140'O)and(enc_CER_PDU(b) == '090140'O)) {setverdict(pass);} else {setverdict(fail);}
17176 Overall verdict: pass
17182 .*---------------------------------------------------------------------*
17183 :h3.CER + DER encoding of REAL, MINUS-INFINITY (primitive)
17184 .*---------------------------------------------------------------------*
17187 <TC - CER + DER encoding of REAL, MINUS-INFINITY (primitive)>
17196 b BERPDU ::= MINUS-INFINITY
17202 import from TempA all;
17203 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17204 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17210 if ((enc_DER_PDU(b) == '090141'O)and(enc_CER_PDU(b) == '090141'O)) {setverdict(pass);} else {setverdict(fail);}
17214 Overall verdict: pass
17220 .*---------------------------------------------------------------------*
17221 :h3.CER + DER encoding of REAL, 1 , IMPICIT TAG
17222 .*---------------------------------------------------------------------*
17225 <TC - CER + DER encoding of REAL, 1 , IMPICIT TAG>
17233 BERPDU ::= [0] IMPLICIT REAL
17240 import from TempA all;
17241 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17242 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17248 if ((enc_DER_PDU(b) == '800603312E452B30'O)and(enc_CER_PDU(b) == '800603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
17252 Overall verdict: pass
17258 .*---------------------------------------------------------------------*
17259 :h3.CER + DER encoding of REAL, 1 , EXPICIT TAG
17260 .*---------------------------------------------------------------------*
17263 <TC - CER + DER encoding of REAL, 1 , EXPICIT TAG>
17271 BERPDU ::= [0] EXPLICIT REAL
17278 import from TempA all;
17279 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17280 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17286 if ((enc_DER_PDU(b) == 'A008090603312E452B30'O)and(enc_CER_PDU(b) == 'A080090603312E452B300000'O)) {setverdict(pass);} else {setverdict(fail);}
17290 Overall verdict: pass
17296 .*---------------------------------------------------------------------*
17297 :h3.CER + DER encoding of BIT STRING, length = 0 (primitive)
17298 .*---------------------------------------------------------------------*
17301 <TC - CER + DER encoding of BIT STRING, length = 0 (primitive)>
17309 BERPDU ::= BIT STRING
17314 import from TempA all;
17315 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17316 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17318 const BERPDU b := ''B
17322 if ((enc_DER_PDU(b) == '030100'O)and(enc_CER_PDU(b) == '030100'O)) {setverdict(pass);} else {setverdict(fail);}
17326 Overall verdict: pass
17332 .*---------------------------------------------------------------------*
17333 :h3.CER + DER encoding of BIT STRING, length = 1 (primitive)
17334 .*---------------------------------------------------------------------*
17337 <TC - CER + DER encoding of BIT STRING, length = 1 (primitive)>
17345 BERPDU ::= BIT STRING
17350 import from TempA all;
17351 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17352 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17354 const BERPDU b := '1'B
17358 if ((enc_DER_PDU(b) == '03020780'O)and(enc_CER_PDU(b) == '03020780'O)) {setverdict(pass);} else {setverdict(fail);}
17362 Overall verdict: pass
17368 .*---------------------------------------------------------------------*
17369 :h3.CER + DER encoding of BIT STRING, length = 7 (primitive)
17370 .*---------------------------------------------------------------------*
17373 <TC - CER + DER encoding of BIT STRING, length = 7 (primitive)>
17381 BERPDU ::= BIT STRING
17386 import from TempA all;
17387 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17388 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17390 const BERPDU b := '1010101'B
17393 if ((enc_DER_PDU(b) == '030201AA'O)and(enc_CER_PDU(b) == '030201AA'O)) {setverdict(pass);} else {setverdict(fail);}
17397 Overall verdict: pass
17403 .*---------------------------------------------------------------------*
17404 :h3.CER + DER encoding of BIT STRING, length = 8 (primitive)
17405 .*---------------------------------------------------------------------*
17408 <TC - CER + DER encoding of BIT STRING, length = 8 (primitive)>
17416 BERPDU ::= BIT STRING
17421 import from TempA all;
17422 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17423 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17425 const BERPDU b := '10101010'B
17428 if ((enc_DER_PDU(b) == '030200AA'O)and(enc_CER_PDU(b) == '030200AA'O)) {setverdict(pass);} else {setverdict(fail);}
17432 Overall verdict: pass
17438 .*---------------------------------------------------------------------*
17439 :h3.CER + DER encoding of BIT STRING, length = 9 (primitive)
17440 .*---------------------------------------------------------------------*
17443 <TC - CER + DER encoding of BIT STRING, length = 9 (primitive)>
17451 BERPDU ::= BIT STRING
17456 import from TempA all;
17457 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17458 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17460 const BERPDU b := '111100001'B
17464 if ((enc_DER_PDU(b) == '030307F080'O)and(enc_CER_PDU(b) == '030307F080'O)) {setverdict(pass);} else {setverdict(fail);}
17468 Overall verdict: pass
17474 .*---------------------------------------------------------------------*
17475 :h3.CER(primitive) + DER(primitive) encoding of BIT STRING, contents length = 1000 octets (999 octets of data and one unused bits octet)
17476 .*---------------------------------------------------------------------*
17479 <TC - CER(primitive) + DER(primitive) encoding of BIT STRING, contents length = 1000 octets (999 octets of data and one unused bits octet)>
17487 BERPDU ::= BIT STRING
17489 b BERPDU ::= 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
17497 import from TempA all;
17498 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17499 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17503 if ((enc_DER_PDU(b) == '038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)and(enc_CER_PDU(b) == '038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)) {setverdict(pass);} else {setverdict(fail);}
17507 Overall verdict: pass
17513 .*---------------------------------------------------------------------*
17514 :h3.CER(constructed) + DER(primitive) encoding of BIT STRING, contents length = 1001 octets (1000 octets of data and one (ENC_02_014 and ENC_02_015) ENC_02_012 and ENC_02_012
17515 .*---------------------------------------------------------------------*
17518 <TC - CER(constructed) + DER(primitive) encoding of BIT STRING, contents length = 1001 octets (1000 octets of data and one (ENC_02_014 and ENC_02_015) ENC_02_012 and ENC_02_012>
17526 BERPDU ::= BIT STRING
17528 b BERPDU ::= 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
17535 import from TempA all;
17536 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17537 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17542 if ((enc_DER_PDU(b) == '038203E900FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)and(enc_CER_PDU(b)
17543 == '2380038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF030200FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
17547 Overall verdict: pass
17553 .*---------------------------------------------------------------------*
17554 :h3.CER + DER encoding of BIT STRING, length = 1, IMPLICIT TAG (primitive)
17555 .*---------------------------------------------------------------------*
17558 <TC - CER + DER encoding of BIT STRING, length = 1, IMPLICIT TAG (primitive)>
17566 BERPDU ::= [0] IMPLICIT BIT STRING
17571 import from TempA all;
17572 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17573 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17575 const BERPDU b := '1'B
17579 if ((enc_DER_PDU(b) == '80020780'O)and(enc_CER_PDU(b) == '80020780'O)) {setverdict(pass);} else {setverdict(fail);}
17583 Overall verdict: pass
17589 .*---------------------------------------------------------------------*
17590 :h3.CER + DER encoding of BIT STRING, length = 1, EXPLICIT TAG (constructed)
17591 .*---------------------------------------------------------------------*
17594 <TC - CER + DER encoding of BIT STRING, length = 1, EXPLICIT TAG (constructed)>
17602 BERPDU ::= [0] EXPLICIT BIT STRING
17607 import from TempA all;
17608 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17609 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17611 const BERPDU b := '1'B
17615 if ((enc_DER_PDU(b) == 'A00403020780'O)and(enc_CER_PDU(b) == 'A080030207800000'O)) {setverdict(pass);} else {setverdict(fail);}
17619 Overall verdict: pass
17625 .*---------------------------------------------------------------------*
17626 :h3. DECODING BIT STRING ,length = 0 ,CER +DER (primitive)
17627 .*---------------------------------------------------------------------*
17630 <TC - DECODING BIT STRING ,length = 0 ,CER +DER (primitive)>
17638 BERPDU ::= BIT STRING
17640 myValue BERPDU ::=''B
17646 import from TempA all;
17648 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17653 if (dec_BER_PDU('030100'O) == myValue)
17656 {setverdict(pass);} else {setverdict(fail);}
17661 Overall verdict: pass
17667 .*---------------------------------------------------------------------*
17668 :h3. DECODING BIT STRING ,length = 0 ,constructed
17669 .*---------------------------------------------------------------------*
17672 <TC - DECODING BIT STRING ,length = 0 ,constructed>
17680 BERPDU ::= BIT STRING
17682 myValue BERPDU ::=''B
17688 import from TempA all;
17690 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17695 if (dec_BER_PDU('2303030100'O) == myValue)
17698 {setverdict(pass);} else {setverdict(fail);}
17703 Overall verdict: pass
17709 .*---------------------------------------------------------------------*
17710 :h3. DECODING BIT STRING ,2xlength = 0 ,constructed
17711 .*---------------------------------------------------------------------*
17714 <TC - DECODING BIT STRING ,2xlength = 0 ,constructed>
17722 BERPDU ::= BIT STRING
17724 myValue BERPDU ::=''B
17730 import from TempA all;
17732 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17737 if (dec_BER_PDU('2306030100030100'O) == myValue)
17740 {setverdict(pass);} else {setverdict(fail);}
17745 Overall verdict: pass
17751 .*---------------------------------------------------------------------*
17752 :h3. DECODING BIT STRING ,length = 0 ,constructed, indefinite
17753 .*---------------------------------------------------------------------*
17756 <TC - DECODING BIT STRING ,length = 0 ,constructed, indefinite>
17764 BERPDU ::= BIT STRING
17766 myIntegerValue BERPDU ::=''B
17772 import from TempA all;
17774 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17779 if (dec_BER_PDU('23800301000000'O) == myIntegerValue)
17782 {setverdict(pass);} else {setverdict(fail);}
17787 Overall verdict: pass
17793 .*---------------------------------------------------------------------*
17794 :h3. DECODING BIT STRING ,length = 1 ,CER + DER, (primitive)
17795 .*---------------------------------------------------------------------*
17798 <TC - DECODING BIT STRING ,length = 1 ,CER + DER, (primitive)>
17806 BERPDU ::= BIT STRING
17808 myValue BERPDU ::='1'B
17814 import from TempA all;
17816 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17821 if (dec_BER_PDU('03020780'O) == myValue)
17824 {setverdict(pass);} else {setverdict(fail);}
17829 Overall verdict: pass
17835 .*---------------------------------------------------------------------*
17836 :h3. DECODING BIT STRING ,length = 1 , (primitive, long form)
17837 .*---------------------------------------------------------------------*
17840 <TC - DECODING BIT STRING ,length = 1 , (primitive, long form)>
17848 BERPDU ::= BIT STRING
17850 myIntegerValue BERPDU ::='1'B
17856 import from TempA all;
17858 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17863 if (dec_BER_PDU('0381020780'O) == myIntegerValue)
17866 {setverdict(pass);} else {setverdict(fail);}
17871 Overall verdict: pass
17877 .*---------------------------------------------------------------------*
17878 :h3. DECODING BIT STRING ,length = 1 , (constructed, short form - short form)
17879 .*---------------------------------------------------------------------*
17882 <TC - DECODING BIT STRING ,length = 1 , (constructed, short form - short form)>
17890 BERPDU ::= BIT STRING
17892 myValue BERPDU ::='1'B
17898 import from TempA all;
17900 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17905 if (dec_BER_PDU('230403020780'O) == myValue)
17908 {setverdict(pass);} else {setverdict(fail);}
17913 Overall verdict: pass
17919 .*---------------------------------------------------------------------*
17920 :h3. DECODING BIT STRING ,length = 1 , (constructed, short form - long form)
17921 .*---------------------------------------------------------------------*
17924 <TC - DECODING BIT STRING ,length = 1 , (constructed, short form - long form)>
17932 BERPDU ::= BIT STRING
17934 myValue BERPDU ::='1'B
17940 import from TempA all;
17942 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17947 if (dec_BER_PDU('23050381020780'O) == myValue)
17950 {setverdict(pass);} else {setverdict(fail);}
17955 Overall verdict: pass
17961 .*---------------------------------------------------------------------*
17962 :h3. DECODING BIT STRING ,length = 1 , (constructed, long form - long form)
17963 .*---------------------------------------------------------------------*
17966 <TC - DECODING BIT STRING ,length = 1 , (constructed, long form - long form)>
17974 BERPDU ::= BIT STRING
17976 myValue BERPDU ::='1'B
17982 import from TempA all;
17984 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17989 if (dec_BER_PDU('2381050381020780'O) == myValue)
17992 {setverdict(pass);} else {setverdict(fail);}
17997 Overall verdict: pass
18003 .*---------------------------------------------------------------------*
18004 :h3. DECODING BIT STRING ,length = 1 , (constructed, indefinite form)
18005 .*---------------------------------------------------------------------*
18008 <TC - DECODING BIT STRING ,length = 1 , (constructed, indefinite form)>
18016 BERPDU ::= BIT STRING
18018 myValue BERPDU ::='1'B
18024 import from TempA all;
18026 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18031 if (dec_BER_PDU('238003810207800000'O) == myValue)
18034 {setverdict(pass);} else {setverdict(fail);}
18039 Overall verdict: pass
18045 .*---------------------------------------------------------------------*
18046 :h3. DECODING BIT STRING ,2xlength = 1 , (constructed, short form - short form)
18047 .*---------------------------------------------------------------------*
18050 <TC - DECODING BIT STRING ,2xlength = 1 , (constructed, short form - short form)>
18058 BERPDU ::= BIT STRING
18060 myValue BERPDU ::='11'B
18066 import from TempA all;
18068 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER:BER_ACCEPT_ALL)" }
18073 if (dec_BER_PDU('23080302078003020780'O) == myValue)
18076 {setverdict(pass);} else {setverdict(fail);}
18081 Overall verdict: pass
18087 .*---------------------------------------------------------------------*
18088 :h3. DECODING BIT STRING ,2xlength = 1 , (constructed inside constructed)
18089 .*---------------------------------------------------------------------*
18092 <TC - DECODING BIT STRING ,2xlength = 1 , (constructed inside constructed)>
18100 BERPDU ::= BIT STRING
18102 myValue BERPDU ::='1'B
18108 import from TempA all;
18110 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18115 if (dec_BER_PDU('2306230403020780'O) == myValue)
18118 {setverdict(pass);} else {setverdict(fail);}
18123 Overall verdict: pass
18129 .*---------------------------------------------------------------------*
18130 :h3. DECODING BIT STRING ,length = 7 ,CER + DER, (primitive)
18131 .*---------------------------------------------------------------------*
18134 <TC - DECODING BIT STRING ,length = 7 ,CER + DER, (primitive)>
18142 BERPDU ::= BIT STRING
18144 myValue BERPDU ::='1010101'B
18150 import from TempA all;
18152 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18157 if (dec_BER_PDU('030201AA'O) == myValue)
18160 {setverdict(pass);} else {setverdict(fail);}
18165 Overall verdict: pass
18171 .*---------------------------------------------------------------------*
18172 :h3. DECODING BIT STRING ,length = 7 , (primitive, long form)
18173 .*---------------------------------------------------------------------*
18176 <TC - DECODING BIT STRING ,length = 7 , (primitive, long form)>
18184 BERPDU ::= BIT STRING
18186 myIntegerValue BERPDU ::='1010101'B
18192 import from TempA all;
18194 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18199 if (dec_BER_PDU('03810201AA'O) == myIntegerValue)
18202 {setverdict(pass);} else {setverdict(fail);}
18207 Overall verdict: pass
18213 .*---------------------------------------------------------------------*
18214 :h3. DECODING BIT STRING ,length = 7 , (constructed, short form - short form)
18215 .*---------------------------------------------------------------------*
18218 <TC - DECODING BIT STRING ,length = 7 , (constructed, short form - short form)>
18226 BERPDU ::= BIT STRING
18228 myValue BERPDU ::='1010101'B
18234 import from TempA all;
18236 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18241 if (dec_BER_PDU('2304030201AA'O) == myValue)
18244 {setverdict(pass);} else {setverdict(fail);}
18249 Overall verdict: pass
18255 .*---------------------------------------------------------------------*
18256 :h3. DECODING BIT STRING ,length = 7 , (constructed, short form - long form)
18257 .*---------------------------------------------------------------------*
18260 <TC - DECODING BIT STRING ,length = 7 , (constructed, short form - long form)>
18268 BERPDU ::= BIT STRING
18270 myValue BERPDU ::='1010101'B
18276 import from TempA all;
18278 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18283 if (dec_BER_PDU('230503810201AA'O) == myValue)
18286 {setverdict(pass);} else {setverdict(fail);}
18291 Overall verdict: pass
18297 .*---------------------------------------------------------------------*
18298 :h3. DECODING BIT STRING ,length = 7 , (constructed, long form - long form)
18299 .*---------------------------------------------------------------------*
18302 <TC - DECODING BIT STRING ,length = 7 , (constructed, long form - long form)>
18310 BERPDU ::= BIT STRING
18312 myValue BERPDU ::='1010101'B
18318 import from TempA all;
18320 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18325 if (dec_BER_PDU('23810503810201AA'O) == myValue)
18328 {setverdict(pass);} else {setverdict(fail);}
18333 Overall verdict: pass
18339 .*---------------------------------------------------------------------*
18340 :h3. DECODING BIT STRING ,length = 7 , (constructed, indefinite form)
18341 .*---------------------------------------------------------------------*
18344 <TC - DECODING BIT STRING ,length = 7 , (constructed, indefinite form)>
18352 BERPDU ::= BIT STRING
18354 myValue BERPDU ::='1010101'B
18360 import from TempA all;
18362 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18367 if (dec_BER_PDU('238003810201AA0000'O) == myValue)
18370 {setverdict(pass);} else {setverdict(fail);}
18375 Overall verdict: pass
18381 .*---------------------------------------------------------------------*
18382 :h3. DECODING BIT STRING ,2xlength = 7 , (constructed, short form - short form)
18383 .*---------------------------------------------------------------------*
18386 <TC - DECODING BIT STRING ,2xlength = 7 , (constructed, short form - short form)>
18394 BERPDU ::= BIT STRING
18396 myValue BERPDU ::='10101011010101'B
18402 import from TempA all;
18404 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18409 if (dec_BER_PDU('2308030201AA030201AA'O) == myValue)
18412 {setverdict(pass);} else {setverdict(fail);}
18417 Overall verdict: pass
18423 .*---------------------------------------------------------------------*
18424 :h3. DECODING BIT STRING ,2xlength = 7 , (constructed inside constructed)
18425 .*---------------------------------------------------------------------*
18428 <TC - DECODING BIT STRING ,2xlength = 7 , (constructed inside constructed)>
18436 BERPDU ::= BIT STRING
18438 myValue BERPDU ::='1010101'B
18444 import from TempA all;
18446 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18451 if (dec_BER_PDU('23062304030201AA'O) == myValue)
18454 {setverdict(pass);} else {setverdict(fail);}
18459 Overall verdict: pass
18465 .*---------------------------------------------------------------------*
18466 :h3. DECODING BIT STRING ,length = 8 ,CER + DER, (primitive)
18467 .*---------------------------------------------------------------------*
18470 <TC - DECODING BIT STRING ,length = 8 ,CER + DER, (primitive)>
18478 BERPDU ::= BIT STRING
18480 myValue BERPDU ::='10101010'B
18486 import from TempA all;
18488 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18493 if (dec_BER_PDU('030200AA'O) == myValue)
18496 {setverdict(pass);} else {setverdict(fail);}
18501 Overall verdict: pass
18507 .*---------------------------------------------------------------------*
18508 :h3. DECODING BIT STRING ,length = 8 , (primitive, long form)
18509 .*---------------------------------------------------------------------*
18512 <TC - DECODING BIT STRING ,length = 8 , (primitive, long form)>
18520 BERPDU ::= BIT STRING
18522 myIntegerValue BERPDU ::='10101010'B
18528 import from TempA all;
18530 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18535 if (dec_BER_PDU('03810200AA'O) == myIntegerValue)
18538 {setverdict(pass);} else {setverdict(fail);}
18543 Overall verdict: pass
18549 .*---------------------------------------------------------------------*
18550 :h3. DECODING BIT STRING ,length = 8 , (constructed, short form - short form)
18551 .*---------------------------------------------------------------------*
18554 <TC - DECODING BIT STRING ,length = 8 , (constructed, short form - short form)>
18562 BERPDU ::= BIT STRING
18564 myValue BERPDU ::='10101010'B
18570 import from TempA all;
18572 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18577 if (dec_BER_PDU('2304030200AA'O) == myValue)
18580 {setverdict(pass);} else {setverdict(fail);}
18585 Overall verdict: pass
18591 .*---------------------------------------------------------------------*
18592 :h3. DECODING BIT STRING ,length = 8 , (constructed, short form - long form)
18593 .*---------------------------------------------------------------------*
18596 <TC - DECODING BIT STRING ,length = 8 , (constructed, short form - long form)>
18604 BERPDU ::= BIT STRING
18606 myValue BERPDU ::='10101010'B
18612 import from TempA all;
18614 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18619 if (dec_BER_PDU('230503810200AA'O) == myValue)
18622 {setverdict(pass);} else {setverdict(fail);}
18627 Overall verdict: pass
18633 .*---------------------------------------------------------------------*
18634 :h3. DECODING BIT STRING ,length = 8 , (constructed, long form - long form)
18635 .*---------------------------------------------------------------------*
18638 <TC - DECODING BIT STRING ,length = 8 , (constructed, long form - long form)>
18646 BERPDU ::= BIT STRING
18648 myValue BERPDU ::='10101010'B
18654 import from TempA all;
18656 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18661 if (dec_BER_PDU('23810503810200AA'O) == myValue)
18664 {setverdict(pass);} else {setverdict(fail);}
18669 Overall verdict: pass
18675 .*---------------------------------------------------------------------*
18676 :h3. DECODING BIT STRING ,length = 8 , (constructed, indefinite form)
18677 .*---------------------------------------------------------------------*
18680 <TC - DECODING BIT STRING ,length = 8 , (constructed, indefinite form)>
18688 BERPDU ::= BIT STRING
18690 myValue BERPDU ::='10101010'B
18696 import from TempA all;
18698 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18703 if (dec_BER_PDU('238003810200AA0000'O) == myValue)
18706 {setverdict(pass);} else {setverdict(fail);}
18711 Overall verdict: pass
18717 .*---------------------------------------------------------------------*
18718 :h3. DECODING BIT STRING ,2xlength = 8 , (constructed, short form - short form)
18719 .*---------------------------------------------------------------------*
18722 <TC - DECODING BIT STRING ,2xlength = 8 , (constructed, short form - short form)>
18730 BERPDU ::= BIT STRING
18732 myValue BERPDU ::='1010101010101010'B
18738 import from TempA all;
18740 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18745 if (dec_BER_PDU('2308030200AA030200AA'O) == myValue)
18748 {setverdict(pass);} else {setverdict(fail);}
18753 Overall verdict: pass
18759 .*---------------------------------------------------------------------*
18760 :h3. DECODING BIT STRING ,2xlength = 8 , (constructed inside constructed)
18761 .*---------------------------------------------------------------------*
18764 <TC - DECODING BIT STRING ,2xlength = 8 , (constructed inside constructed)>
18772 BERPDU ::= BIT STRING
18774 myValue BERPDU ::='10101010'B
18780 import from TempA all;
18782 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18787 if (dec_BER_PDU('23062304030200AA'O) == myValue)
18790 {setverdict(pass);} else {setverdict(fail);}
18795 Overall verdict: pass
18801 .*---------------------------------------------------------------------*
18802 :h3. DECODING BIT STRING ,length = 9 ,CER + DER, (primitive)
18803 .*---------------------------------------------------------------------*
18806 <TC - DECODING BIT STRING ,length = 9 ,CER + DER, (primitive)>
18814 BERPDU ::= BIT STRING
18816 myValue BERPDU ::='111100001'B
18822 import from TempA all;
18824 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18829 if (dec_BER_PDU( '030307F080'O) == myValue)
18832 {setverdict(pass);} else {setverdict(fail);}
18837 Overall verdict: pass
18843 .*---------------------------------------------------------------------*
18844 :h3. DECODING BIT STRING ,length = 9 , (primitive, long form)
18845 .*---------------------------------------------------------------------*
18848 <TC - DECODING BIT STRING ,length = 9 , (primitive, long form)>
18856 BERPDU ::= BIT STRING
18858 myIntegerValue BERPDU ::='111100001'B
18864 import from TempA all;
18866 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18871 if (dec_BER_PDU('03810307F080'O) == myIntegerValue)
18874 {setverdict(pass);} else {setverdict(fail);}
18879 Overall verdict: pass
18885 .*---------------------------------------------------------------------*
18886 :h3. DECODING BIT STRING ,length = 9 , (constructed, short form - short form)
18887 .*---------------------------------------------------------------------*
18890 <TC - DECODING BIT STRING ,length = 9 , (constructed, short form - short form)>
18898 BERPDU ::= BIT STRING
18900 myValue BERPDU ::='111100001'B
18906 import from TempA all;
18908 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18913 if (dec_BER_PDU('2305030307F080'O) == myValue)
18916 {setverdict(pass);} else {setverdict(fail);}
18921 Overall verdict: pass
18927 .*---------------------------------------------------------------------*
18928 :h3. DECODING BIT STRING ,length = 9 , (constructed, short form - long form)
18929 .*---------------------------------------------------------------------*
18932 <TC - DECODING BIT STRING ,length = 9 , (constructed, short form - long form)>
18940 BERPDU ::= BIT STRING
18942 myValue BERPDU ::='111100001'B
18948 import from TempA all;
18950 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18955 if (dec_BER_PDU('230603810307F080'O) == myValue)
18958 {setverdict(pass);} else {setverdict(fail);}
18963 Overall verdict: pass
18969 .*---------------------------------------------------------------------*
18970 :h3. DECODING BIT STRING ,length = 9 , (constructed, long form - long form)
18971 .*---------------------------------------------------------------------*
18974 <TC - DECODING BIT STRING ,length = 9 , (constructed, long form - long form)>
18982 BERPDU ::= BIT STRING
18984 myValue BERPDU ::='111100001'B
18990 import from TempA all;
18992 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18997 if (dec_BER_PDU('23810603810307F080'O) == myValue)
19000 {setverdict(pass);} else {setverdict(fail);}
19005 Overall verdict: pass
19011 .*---------------------------------------------------------------------*
19012 :h3. DECODING BIT STRING ,length = 9 , (constructed, indefinite form)
19013 .*---------------------------------------------------------------------*
19016 <TC - DECODING BIT STRING ,length = 9 , (constructed, indefinite form)>
19024 BERPDU ::= BIT STRING
19026 myValue BERPDU ::='111100001'B
19032 import from TempA all;
19034 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19039 if (dec_BER_PDU('238003810307F0800000'O) == myValue)
19042 {setverdict(pass);} else {setverdict(fail);}
19047 Overall verdict: pass
19053 .*---------------------------------------------------------------------*
19054 :h3. DECODING BIT STRING ,2xlength = 9 , (constructed, short form - short form)
19055 .*---------------------------------------------------------------------*
19058 <TC - DECODING BIT STRING ,2xlength = 9 , (constructed, short form - short form)>
19066 BERPDU ::= BIT STRING
19068 myValue BERPDU ::='111100001111100001'B
19074 import from TempA all;
19076 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19081 if (dec_BER_PDU('230A030307F080030307F080'O) == myValue)
19084 {setverdict(pass);} else {setverdict(fail);}
19089 Overall verdict: pass
19095 .*---------------------------------------------------------------------*
19096 :h3. DECODING BIT STRING ,length = 9 , (constructed inside constructed)
19097 .*---------------------------------------------------------------------*
19100 <TC - DECODING BIT STRING ,length = 9 , (constructed inside constructed)>
19108 BERPDU ::= BIT STRING
19110 myValue BERPDU ::='111100001'B
19116 import from TempA all;
19118 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19123 if (dec_BER_PDU('23072305030307F080'O) == myValue)
19126 {setverdict(pass);} else {setverdict(fail);}
19131 Overall verdict: pass
19137 .*---------------------------------------------------------------------*
19138 :h3. DECODING BIT STRING ,length = 1000 CER + DER, primitive (999 octets of data and one unused bits octet)
19139 .*---------------------------------------------------------------------*
19142 <TC - DECODING BIT STRING ,length = 1000 CER + DER, primitive (999 octets of data and one unused bits octet)>
19150 BERPDU ::= BIT STRING
19152 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19158 import from TempA all;
19160 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19165 if (dec_BER_PDU('038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue)
19168 {setverdict(pass);} else {setverdict(fail);}
19173 Overall verdict: pass
19179 .*---------------------------------------------------------------------*
19180 :h3. DECODING BIT STRING ,length = 1000 , primitive longer form (999 octets of data and one unused bits octet)
19181 .*---------------------------------------------------------------------*
19184 <TC - DECODING BIT STRING ,length = 1000 , primitive longer form (999 octets of data and one unused bits octet)>
19192 BERPDU ::= BIT STRING
19194 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19200 import from TempA all;
19202 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19207 if (dec_BER_PDU('03830003E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue)
19210 {setverdict(pass);} else {setverdict(fail);}
19215 Overall verdict: pass
19221 .*---------------------------------------------------------------------*
19222 :h3. DECODING BIT STRING ,length = 1000 , constructed long form -long form (999 octets of data and one unused bits octet)
19223 .*---------------------------------------------------------------------*
19226 <TC - DECODING BIT STRING ,length = 1000 , constructed long form -long form (999 octets of data and one unused bits octet)>
19234 BERPDU ::= BIT STRING
19236 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19242 import from TempA all;
19244 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19249 if (dec_BER_PDU('238203EC038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue)
19252 {setverdict(pass);} else {setverdict(fail);}
19257 Overall verdict: pass
19263 .*---------------------------------------------------------------------*
19264 :h3. DECODING BIT STRING ,length = 1000 , constructed indefinite form (999 octets of data and one unused bits octet)
19265 .*---------------------------------------------------------------------*
19268 <TC - DECODING BIT STRING ,length = 1000 , constructed indefinite form (999 octets of data and one unused bits octet)>
19276 BERPDU ::= BIT STRING
19278 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19284 import from TempA all;
19286 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19291 if (dec_BER_PDU('2380038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000'O) == myValue)
19294 {setverdict(pass);} else {setverdict(fail);}
19299 Overall verdict: pass
19305 .*---------------------------------------------------------------------*
19306 :h3. DECODING BIT STRING ,2xlength = 1000 , constructed (999 octets of data and one unused bits octet)
19307 .*---------------------------------------------------------------------*
19310 <TC - DECODING BIT STRING ,2xlength = 1000 , constructed (999 octets of data and one unused bits octet)>
19318 BERPDU ::= BIT STRING
19320 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19326 import from TempA all;
19328 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19333 if (dec_BER_PDU('238207D8038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue)
19336 {setverdict(pass);} else {setverdict(fail);}
19341 Overall verdict: pass
19347 .*---------------------------------------------------------------------*
19348 :h3. DECODING BIT STRING ,length = 1001 DER , primitive (1000 octets of data and one unused bits octet)
19349 .*---------------------------------------------------------------------*
19352 <TC - DECODING BIT STRING ,length = 1001 DER , primitive (1000 octets of data and one unused bits octet)>
19360 BERPDU ::= BIT STRING
19362 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19368 import from TempA all;
19370 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19375 if (dec_BER_PDU('038203E900FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue)
19378 {setverdict(pass);} else {setverdict(fail);}
19383 Overall verdict: pass
19389 .*---------------------------------------------------------------------*
19390 :h3. DECODING BIT STRING ,length = 1001 CER , constructed (1000 octets of data and one unused bits octet)
19391 .*---------------------------------------------------------------------*
19394 <TC - DECODING BIT STRING ,length = 1001 CER , constructed (1000 octets of data and one unused bits octet)>
19402 BERPDU ::= BIT STRING
19404 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19410 import from TempA all;
19412 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19417 if (dec_BER_PDU('238203F0038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF030200FF'O) == myValue)
19420 {setverdict(pass);} else {setverdict(fail);}
19425 Overall verdict: pass
19431 .*---------------------------------------------------------------------*
19432 :h3. DECODING BIT STRING ,length = 1001 , constructed (1000 octets of data and one unused bits octet)
19433 .*---------------------------------------------------------------------*
19436 <TC - DECODING BIT STRING ,length = 1001 , constructed (1000 octets of data and one unused bits octet)>
19444 BERPDU ::= BIT STRING
19446 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19452 import from TempA all;
19454 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19459 if (dec_BER_PDU('238203ED038203E900FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue)
19462 {setverdict(pass);} else {setverdict(fail);}
19467 Overall verdict: pass
19473 .*---------------------------------------------------------------------*
19474 :h3. DECODING BIT STRING CER +DER ,length = 1 , IMPLICIT TAG primitive
19475 .*---------------------------------------------------------------------*
19478 <TC - DECODING BIT STRING CER +DER ,length = 1 , IMPLICIT TAG primitive >
19486 BERPDU ::= [0] IMPLICIT BIT STRING
19488 myValue BERPDU ::='1'B
19494 import from TempA all;
19496 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19501 if (dec_BER_PDU('80020780'O) == myValue)
19504 {setverdict(pass);} else {setverdict(fail);}
19509 Overall verdict: pass
19515 .*---------------------------------------------------------------------*
19516 :h3. DECODING BIT STRING CER ,length = 1 , EXPLICIT TAG (constructed )
19517 .*---------------------------------------------------------------------*
19520 <TC - DECODING BIT STRING CER ,length = 1 , EXPLICIT TAG (constructed )>
19528 BERPDU ::= BIT STRING
19530 myValue BERPDU ::='1'B
19536 import from TempA all;
19538 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19543 if (dec_BER_PDU('A080030207800000'O) == myValue)
19546 {setverdict(pass);} else {setverdict(fail);}
19551 Overall verdict: pass
19557 .*---------------------------------------------------------------------*
19558 :h3. DECODING BIT STRING DER ,length = 1 EXPLICIT TAG , (constructed )
19559 .*---------------------------------------------------------------------*
19562 <TC - DECODING BIT STRING DER ,length = 1 EXPLICIT TAG , (constructed )>
19570 BERPDU ::= BIT STRING
19572 myValue BERPDU ::='1'B
19578 import from TempA all;
19580 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19585 if (dec_BER_PDU('A00403020780'O) == myValue)
19588 {setverdict(pass);} else {setverdict(fail);}
19593 Overall verdict: pass
19599 .*---------------------------------------------------------------------*
19600 :h3.CER + DER encoding of OCTETSTRING, length = 0 (primitive)
19601 .*---------------------------------------------------------------------*
19604 <TC - CER + DER encoding of OCTETSTRING, length = 0 (primitive)>
19612 BERPDU ::= OCTET STRING
19617 import from TempA all;
19618 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
19619 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
19621 const BERPDU b := ''O
19625 if ((enc_DER_PDU(b) == '0400'O)and(enc_CER_PDU(b) == '0400'O)) {setverdict(pass);} else {setverdict(fail);}
19629 Overall verdict: pass
19635 .*---------------------------------------------------------------------*
19636 :h3.CER + DER encoding of OCTETSTRING, length = 2 (primitive)
19637 .*---------------------------------------------------------------------*
19640 <TC - CER + DER encoding of OCTETSTRING, length = 2 (primitive)>
19648 BERPDU ::= OCTET STRING
19653 import from TempA all;
19654 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
19655 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
19657 const BERPDU b := 'FFFF'O
19661 if ((enc_DER_PDU(b) == '0402FFFF'O)and(enc_CER_PDU(b) == '0402FFFF'O)) {setverdict(pass);} else {setverdict(fail);}
19665 Overall verdict: pass
19671 .*---------------------------------------------------------------------*
19672 :h3.CER + DER encoding of OCTETSTRING, length = 1000 (primitive)
19673 .*---------------------------------------------------------------------*
19676 <TC - CER + DER encoding of OCTETSTRING, length = 1000 (primitive)>
19684 BERPDU ::= OCTET STRING
19689 import from TempA all;
19690 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
19691 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
19693 const BERPDU b := 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O
19697 if ((enc_DER_PDU(b) == '048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)and(enc_CER_PDU(b) == '048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)) {setverdict(pass);} else {setverdict(fail);}
19701 Overall verdict: pass
19707 .*---------------------------------------------------------------------*
19708 :h3.CER(constructed) + DER(primitive) encoding of OCTETSTRING, length = 1001 (ENC_02_014 and ENC_02_015)
19709 .*---------------------------------------------------------------------*
19712 <TC - CER(constructed) + DER(primitive) encoding of OCTETSTRING, length = 1001 (ENC_02_014 and ENC_02_015)>
19720 BERPDU ::= OCTET STRING
19725 import from TempA all;
19726 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
19727 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
19730 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O
19734 if ((enc_DER_PDU(b) == '048203E9FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)and(enc_CER_PDU(b)
19735 == '2480048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0401FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
19739 Overall verdict: pass
19745 .*---------------------------------------------------------------------*
19746 :h3.CER + DER encoding of OCTETSTRING, IMPLICIT TAG length = 2 (primitive)
19747 .*---------------------------------------------------------------------*
19750 <TC - CER + DER encoding of OCTETSTRING, IMPLICIT TAG length = 2 (primitive)>
19758 BERPDU ::= [0] IMPLICIT OCTET STRING
19763 import from TempA all;
19764 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
19765 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
19767 const BERPDU b := 'FFFF'O
19771 if ((enc_DER_PDU(b) == '8002FFFF'O)and(enc_CER_PDU(b) == '8002FFFF'O)) {setverdict(pass);} else {setverdict(fail);}
19775 Overall verdict: pass
19781 .*---------------------------------------------------------------------*
19782 :h3.CER + DER encoding of OCTETSTRING,EXPICIT TAG , length = 2 (constructed)
19783 .*---------------------------------------------------------------------*
19786 <TC - CER + DER encoding of OCTETSTRING,EXPICIT TAG , length = 2 (constructed)>
19794 BERPDU ::= [0] EXPLICIT OCTET STRING
19799 import from TempA all;
19800 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
19801 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
19803 const BERPDU b := 'FFFF'O
19807 if ((enc_DER_PDU(b) == 'A0040402FFFF'O)and(enc_CER_PDU(b) == 'A0800402FFFF0000'O)) {setverdict(pass);} else {setverdict(fail);}
19811 Overall verdict: pass
19817 .*---------------------------------------------------------------------*
19818 :h3. DECODING OCTETSTRING ,length = 0 ,CER +DER (primitive)
19819 .*---------------------------------------------------------------------*
19822 <TC - DECODING OCTETSTRING ,length = 0 ,CER +DER (primitive)>
19830 BERPDU ::= OCTET STRING
19832 myIntegerValue BERPDU ::=''H
19838 import from TempA all;
19840 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19845 if (dec_BER_PDU('0400'O) == myIntegerValue)
19848 {setverdict(pass);} else {setverdict(fail);}
19853 Overall verdict: pass
19859 .*---------------------------------------------------------------------*
19860 :h3. DECODING OCTETSTRING ,length = 0 ,constructed
19861 .*---------------------------------------------------------------------*
19864 <TC - DECODING OCTETSTRING ,length = 0 ,constructed>
19872 BERPDU ::= OCTET STRING
19874 myIntegerValue BERPDU ::=''H
19880 import from TempA all;
19882 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19887 if (dec_BER_PDU('24020400'O) == myIntegerValue)
19890 {setverdict(pass);} else {setverdict(fail);}
19895 Overall verdict: pass
19901 .*---------------------------------------------------------------------*
19902 :h3. DECODING OCTETSTRING ,2xlength = 0 ,constructed
19903 .*---------------------------------------------------------------------*
19906 <TC - DECODING OCTETSTRING ,2xlength = 0 ,constructed>
19914 BERPDU ::= OCTET STRING
19916 myIntegerValue BERPDU ::=''H
19922 import from TempA all;
19924 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19929 if (dec_BER_PDU('240404000400'O) == myIntegerValue)
19932 {setverdict(pass);} else {setverdict(fail);}
19937 Overall verdict: pass
19943 .*---------------------------------------------------------------------*
19944 :h3. DECODING OCTETSTRING ,length = 0 ,constructed, indefinite
19945 .*---------------------------------------------------------------------*
19948 <TC - DECODING OCTETSTRING ,length = 0 ,constructed, indefinite>
19956 BERPDU ::= OCTET STRING
19958 myIntegerValue BERPDU ::=''H
19964 import from TempA all;
19966 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19971 if (dec_BER_PDU('248004000000'O) == myIntegerValue)
19974 {setverdict(pass);} else {setverdict(fail);}
19979 Overall verdict: pass
19985 .*---------------------------------------------------------------------*
19986 :h3. DECODING OCTETSTRING ,length = 2 ,CER + DER, (primitive)
19987 .*---------------------------------------------------------------------*
19990 <TC - DECODING OCTETSTRING ,length = 2 ,CER + DER, (primitive)>
19998 BERPDU ::= OCTET STRING
20000 myIntegerValue BERPDU ::='FFFF'H
20006 import from TempA all;
20008 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20013 if (dec_BER_PDU('0402FFFF'O) == myIntegerValue)
20016 {setverdict(pass);} else {setverdict(fail);}
20021 Overall verdict: pass
20027 .*---------------------------------------------------------------------*
20028 :h3. DECODING OCTETSTRING ,length = 2 , (primitive, long form)
20029 .*---------------------------------------------------------------------*
20032 <TC - DECODING OCTETSTRING ,length = 2 , (primitive, long form)>
20040 BERPDU ::= OCTET STRING
20042 myIntegerValue BERPDU ::='FFFF'H
20048 import from TempA all;
20050 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20055 if (dec_BER_PDU('048102FFFF'O) == myIntegerValue)
20058 {setverdict(pass);} else {setverdict(fail);}
20063 Overall verdict: pass
20069 .*---------------------------------------------------------------------*
20070 :h3. DECODING OCTETSTRING ,length = 2 ,constructed, short form - short form
20071 .*---------------------------------------------------------------------*
20074 <TC - DECODING OCTETSTRING ,length = 2 ,constructed, short form - short form>
20082 BERPDU ::= OCTET STRING
20084 myIntegerValue BERPDU ::='FFFF'H
20090 import from TempA all;
20092 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20097 if (dec_BER_PDU('24040402FFFF'O) == myIntegerValue)
20100 {setverdict(pass);} else {setverdict(fail);}
20105 Overall verdict: pass
20111 .*---------------------------------------------------------------------*
20112 :h3. DECODING OCTETSTRING ,length = 2 ,constructed, short form - long form
20113 .*---------------------------------------------------------------------*
20116 <TC - DECODING OCTETSTRING ,length = 2 ,constructed, short form - long form>
20124 BERPDU ::= OCTET STRING
20126 myIntegerValue BERPDU ::='FFFF'H
20132 import from TempA all;
20134 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20139 if (dec_BER_PDU('2405048102FFFF'O) == myIntegerValue)
20142 {setverdict(pass);} else {setverdict(fail);}
20147 Overall verdict: pass
20153 .*---------------------------------------------------------------------*
20154 :h3. DECODING OCTETSTRING ,length = 2 ,constructed, long form - long form
20155 .*---------------------------------------------------------------------*
20158 <TC - DECODING OCTETSTRING ,length = 2 ,constructed, long form - long form>
20166 BERPDU ::= OCTET STRING
20168 myIntegerValue BERPDU ::='FFFF'H
20174 import from TempA all;
20176 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20181 if (dec_BER_PDU('248105048102FFFF'O) == myIntegerValue)
20184 {setverdict(pass);} else {setverdict(fail);}
20189 Overall verdict: pass
20195 .*---------------------------------------------------------------------*
20196 :h3. DECODING OCTETSTRING ,length = 2 ,constructed, indefinite form
20197 .*---------------------------------------------------------------------*
20200 <TC - DECODING OCTETSTRING ,length = 2 ,constructed, indefinite form>
20208 BERPDU ::= OCTET STRING
20210 myIntegerValue BERPDU ::='FFFF'H
20216 import from TempA all;
20218 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20223 if (dec_BER_PDU('24800402FFFF0000'O) == myIntegerValue)
20226 {setverdict(pass);} else {setverdict(fail);}
20231 Overall verdict: pass
20237 .*---------------------------------------------------------------------*
20238 :h3. DECODING OCTETSTRING ,2xlength = 2 ,constructed, short form - short form
20239 .*---------------------------------------------------------------------*
20242 <TC - DECODING OCTETSTRING ,2xlength = 2 ,constructed, short form - short form>
20250 BERPDU ::= OCTET STRING
20252 myIntegerValue BERPDU ::='FFFFFFFF'H
20258 import from TempA all;
20260 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20265 if (dec_BER_PDU('24080402FFFF0402FFFF'O) == myIntegerValue)
20268 {setverdict(pass);} else {setverdict(fail);}
20273 Overall verdict: pass
20279 .*---------------------------------------------------------------------*
20280 :h3. DECODING OCTETSTRING ,length = 2 ,constructed form inside constructed form
20281 .*---------------------------------------------------------------------*
20284 <TC - DECODING OCTETSTRING ,length = 2 ,constructed form inside constructed form>
20292 BERPDU ::= OCTET STRING
20294 myIntegerValue BERPDU ::='FFFF'H
20300 import from TempA all;
20302 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20307 if (dec_BER_PDU('240624040402FFFF'O) == myIntegerValue)
20310 {setverdict(pass);} else {setverdict(fail);}
20315 Overall verdict: pass
20321 .*---------------------------------------------------------------------*
20322 :h3. DECODING OCTETSTRING ,length = 1000 ,CER + DER, (primitive)
20323 .*---------------------------------------------------------------------*
20326 <TC - DECODING OCTETSTRING ,length = 1000 ,CER + DER, (primitive)>
20334 BERPDU ::= OCTET STRING
20336 myIntegerValue BERPDU
20337 ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20343 import from TempA all;
20345 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20350 if (dec_BER_PDU('048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue)
20353 {setverdict(pass);} else {setverdict(fail);}
20358 Overall verdict: pass
20364 .*---------------------------------------------------------------------*
20365 :h3. DECODING OCTETSTRING ,length = 1000 , (primitive, longer form)
20366 .*---------------------------------------------------------------------*
20369 <TC - DECODING OCTETSTRING ,length = 1000 , (primitive, longer form)>
20377 BERPDU ::= OCTET STRING
20379 myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20385 import from TempA all;
20387 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20392 if (dec_BER_PDU('04830003E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue)
20395 {setverdict(pass);} else {setverdict(fail);}
20400 Overall verdict: pass
20406 .*---------------------------------------------------------------------*
20407 :h3. DECODING OCTETSTRING ,length = 1000 ,constructed, long form -long form
20408 .*---------------------------------------------------------------------*
20411 <TC - DECODING OCTETSTRING ,length = 1000 ,constructed, long form -long form>
20419 BERPDU ::= OCTET STRING
20421 myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20427 import from TempA all;
20429 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20434 if (dec_BER_PDU('248203EC048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue)
20437 {setverdict(pass);} else {setverdict(fail);}
20442 Overall verdict: pass
20448 .*---------------------------------------------------------------------*
20449 :h3. DECODING OCTETSTRING ,length = 1000 ,constructed, indefinite form
20450 .*---------------------------------------------------------------------*
20453 <TC - DECODING OCTETSTRING ,length = 1000 ,constructed, indefinite form>
20461 BERPDU ::= OCTET STRING
20463 myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20469 import from TempA all;
20471 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20476 if (dec_BER_PDU('2480048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000'O) == myIntegerValue)
20479 {setverdict(pass);} else {setverdict(fail);}
20484 Overall verdict: pass
20490 .*---------------------------------------------------------------------*
20491 :h3. DECODING OCTETSTRING ,2xlength = 1000 ,constructed, short form - short form
20492 .*---------------------------------------------------------------------*
20495 <TC - DECODING OCTETSTRING ,2xlength = 1000 ,constructed, short form - short form>
20503 BERPDU ::= OCTET STRING
20505 myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20511 import from TempA all;
20513 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20518 if (dec_BER_PDU('248207D8048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue)
20521 {setverdict(pass);} else {setverdict(fail);}
20526 Overall verdict: pass
20532 .*---------------------------------------------------------------------*
20533 :h3. DECODING OCTETSTRING ,length = 1001 ,CER (constructed, indefinite form. segmented)
20534 .*---------------------------------------------------------------------*
20537 <TC - DECODING OCTETSTRING ,length = 1001 ,CER (constructed, indefinite form. segmented)>
20545 BERPDU ::= OCTET STRING
20546 myIntegerValue BERPDU ::= 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20553 import from TempA all;
20555 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20560 if (dec_BER_PDU('2480048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0401FF0000'O) == myIntegerValue)
20563 {setverdict(pass);} else {setverdict(fail);}
20568 Overall verdict: pass
20574 .*---------------------------------------------------------------------*
20575 :h3. DECODING OCTETSTRING ,length = 1001 ,DER (primitive)
20576 .*---------------------------------------------------------------------*
20579 <TC - DECODING OCTETSTRING ,length = 1001 ,DER (primitive)>
20587 BERPDU ::= OCTET STRING
20588 myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20596 import from TempA all;
20598 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20603 if (dec_BER_PDU('048203E9FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue)
20606 {setverdict(pass);} else {setverdict(fail);}
20611 Overall verdict: pass
20617 .*---------------------------------------------------------------------*
20618 :h3. DECODING OCTETSTRING ,length = 1001 ,constructed, definite form
20619 .*---------------------------------------------------------------------*
20622 <TC - DECODING OCTETSTRING ,length = 1001 ,constructed, definite form>
20630 BERPDU ::= OCTET STRING
20631 myIntegerValue BERPDU ::= 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20638 import from TempA all;
20640 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20645 if (dec_BER_PDU('248203ED048203E9FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue)
20648 {setverdict(pass);} else {setverdict(fail);}
20653 Overall verdict: pass
20659 .*---------------------------------------------------------------------*
20660 :h3. DECODING OCTETSTRING ,length = 2 ,CER + DER,IMPLICIT TAG (primitive)
20661 .*---------------------------------------------------------------------*
20664 <TC - DECODING OCTETSTRING ,length = 2 ,CER + DER,IMPLICIT TAG (primitive)>
20672 BERPDU ::= [0] IMPLICIT OCTET STRING
20674 myIntegerValue BERPDU ::='FFFF'H
20680 import from TempA all;
20682 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20687 if (dec_BER_PDU('8002FFFF'O) == myIntegerValue)
20690 {setverdict(pass);} else {setverdict(fail);}
20695 Overall verdict: pass
20701 .*---------------------------------------------------------------------*
20702 :h3. DECODING OCTETSTRING ,length = 2 ,CER ,EXPLICIT TAG (constructed)
20703 .*---------------------------------------------------------------------*
20706 <TC - DECODING OCTETSTRING ,length = 2 ,CER ,EXPLICIT TAG (constructed)>
20714 BERPDU ::= [0] EXPLICIT OCTET STRING
20716 myIntegerValue BERPDU ::='FFFF'H
20722 import from TempA all;
20724 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20729 if (dec_BER_PDU('A0800402FFFF0000'O) == myIntegerValue)
20732 {setverdict(pass);} else {setverdict(fail);}
20737 Overall verdict: pass
20743 .*---------------------------------------------------------------------*
20744 :h3. DECODING OCTETSTRING ,length = 2 ,DER,EXPLICIT TAG (constructed)
20745 .*---------------------------------------------------------------------*
20748 <TC - DECODING OCTETSTRING ,length = 2 ,DER,EXPLICIT TAG (constructed)>
20756 BERPDU ::= OCTET STRING
20758 myIntegerValue BERPDU ::='FFFF'H
20764 import from TempA all;
20766 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20771 if (dec_BER_PDU('A0040402FFFF'O) == myIntegerValue)
20774 {setverdict(pass);} else {setverdict(fail);}
20779 Overall verdict: pass
20785 .*---------------------------------------------------------------------*
20786 :h3. DER + CER encoding of NULL
20787 .*---------------------------------------------------------------------*
20790 <TC - DER + CER encoding of NULL >
20791 START OF NULL SECTION
20804 import from TempA all;
20805 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
20806 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
20808 const BERPDU b := NULL
20812 if ((enc_DER_PDU(b) == '0500'O)and(enc_CER_PDU(b) == '0500'O)) {setverdict(pass);} else {setverdict(fail);}
20816 Overall verdict: pass
20822 .*---------------------------------------------------------------------*
20823 :h3. DER + CER encoding of NULL with Context Specific TAG, EXPLICIT
20824 .*---------------------------------------------------------------------*
20827 <TC - DER + CER encoding of NULL with Context Specific TAG, EXPLICIT>
20835 BERPDU ::= [0] EXPLICIT NULL
20840 import from TempA all;
20841 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
20842 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
20844 const BERPDU b := NULL
20848 if ((enc_DER_PDU(b) == 'A0020500'O)and(enc_CER_PDU(b) == 'A08005000000'O)) {setverdict(pass);} else {setverdict(fail);}
20852 Overall verdict: pass
20858 .*---------------------------------------------------------------------*
20859 :h3. DER + CER encoding of NULL with PRIVATE TAG, EXPLICIT
20860 .*---------------------------------------------------------------------*
20863 <TC - DER + CER encoding of NULL with PRIVATE TAG, EXPLICIT>
20871 BERPDU ::= [PRIVATE 1] EXPLICIT NULL
20876 import from TempA all;
20877 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
20878 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
20880 const BERPDU b := NULL
20884 if ((enc_DER_PDU(b) == 'E1020500'O)and(enc_CER_PDU(b) == 'E18005000000'O)) {setverdict(pass);} else {setverdict(fail);}
20888 Overall verdict: pass
20894 .*---------------------------------------------------------------------*
20895 :h3. DER + CER encoding of NULL with APPLICATION TAG, EXPLICIT
20896 .*---------------------------------------------------------------------*
20899 <TC - DER + CER encoding of NULL with APPLICATION TAG, EXPLICIT>
20907 BERPDU ::= [APPLICATION 2] EXPLICIT NULL
20912 import from TempA all;
20913 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
20914 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
20916 const BERPDU b := NULL
20920 if ((enc_DER_PDU(b) == '62020500'O)and(enc_CER_PDU(b) == '628005000000'O)) {setverdict(pass);} else {setverdict(fail);}
20924 Overall verdict: pass
20930 .*---------------------------------------------------------------------*
20931 :h3. DER + CER encoding of NULL with Context Specific TAG, IMPLICIT
20932 .*---------------------------------------------------------------------*
20935 <TC - DER + CER encoding of NULL with Context Specific TAG, IMPLICIT>
20943 BERPDU ::= [0] IMPLICIT NULL
20948 import from TempA all;
20949 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
20950 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
20952 const BERPDU b := NULL
20956 if ((enc_DER_PDU(b) == '8000'O)and(enc_CER_PDU(b) == '8000'O)) {setverdict(pass);} else {setverdict(fail);}
20960 Overall verdict: pass
20966 .*---------------------------------------------------------------------*
20967 :h3. DER + CER encoding of NULL with PRIVATE TAG, IMPLICIT
20968 .*---------------------------------------------------------------------*
20971 <TC - DER + CER encoding of NULL with PRIVATE TAG, IMPLICIT>
20979 BERPDU ::= [PRIVATE 1] IMPLICIT NULL
20984 import from TempA all;
20985 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
20986 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
20988 const BERPDU b := NULL
20992 if ((enc_DER_PDU(b) == 'C100'O)and(enc_CER_PDU(b) == 'C100'O)) {setverdict(pass);} else {setverdict(fail);}
20996 Overall verdict: pass
21002 .*---------------------------------------------------------------------*
21003 :h3. DER + CER encoding of NULL with APPLICATION TAG, IMPLICIT
21004 .*---------------------------------------------------------------------*
21007 <TC - DER + CER encoding of NULL with APPLICATION TAG, IMPLICIT>
21015 BERPDU ::= [APPLICATION 2] IMPLICIT NULL
21020 import from TempA all;
21021 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
21022 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
21024 const BERPDU b := NULL
21028 if ((enc_DER_PDU(b) == '4200'O)and(enc_CER_PDU(b) == '4200'O)) {setverdict(pass);} else {setverdict(fail);}
21032 Overall verdict: pass
21038 .*---------------------------------------------------------------------*
21039 :h3. DECODING NULL, CER+DER
21040 .*---------------------------------------------------------------------*
21043 <TC - DECODING NULL, CER+DER>
21053 myNullValue BERPDU ::= NULL
21059 import from TempA all;
21061 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21066 if (dec_BER_PDU('0500'O) == myNullValue)
21069 {setverdict(pass);} else {setverdict(fail);}
21074 Overall verdict: pass
21080 .*---------------------------------------------------------------------*
21081 :h3. DECODING NULL, (LENGTH OF LENGTH = 1)
21082 .*---------------------------------------------------------------------*
21085 <TC - DECODING NULL, (LENGTH OF LENGTH = 1)>
21095 myNullValue BERPDU ::= NULL
21101 import from TempA all;
21103 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21108 if (dec_BER_PDU('058100'O) == myNullValue)
21111 {setverdict(pass);} else {setverdict(fail);}
21116 Overall verdict: pass
21122 .*---------------------------------------------------------------------*
21123 :h3. DECODING NULL, (LENGTH OF LENGTH = 2)
21124 .*---------------------------------------------------------------------*
21127 <TC - DECODING NULL, (LENGTH OF LENGTH = 2)>
21137 myNullValue BERPDU ::= NULL
21143 import from TempA all;
21145 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21150 if (dec_BER_PDU('05820000'O) == myNullValue)
21153 {setverdict(pass);} else {setverdict(fail);}
21158 Overall verdict: pass
21164 .*---------------------------------------------------------------------*
21165 :h3. DECODING [0] EXPLICIT NULL , DER
21166 .*---------------------------------------------------------------------*
21169 <TC - DECODING [0] EXPLICIT NULL , DER>
21177 BERPDU ::= [0] EXPLICIT NULL
21179 myNullValue BERPDU ::= NULL
21185 import from TempA all;
21187 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21192 if (dec_BER_PDU('A0020500'O) == myNullValue)
21195 {setverdict(pass);} else {setverdict(fail);}
21200 Overall verdict: pass
21206 .*---------------------------------------------------------------------*
21207 :h3. DECODING [0] EXPLICIT NULL, CER
21208 .*---------------------------------------------------------------------*
21211 <TC - DECODING [0] EXPLICIT NULL, CER>
21219 BERPDU ::= [0] EXPLICIT NULL
21221 myNullValue BERPDU ::= NULL
21227 import from TempA all;
21229 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21234 if (dec_BER_PDU('A08005000000'O) == myNullValue)
21237 {setverdict(pass);} else {setverdict(fail);}
21242 Overall verdict: pass
21248 .*---------------------------------------------------------------------*
21249 :h3. DECODING [0] EXPLICIT NULL, Short form - short form
21250 .*---------------------------------------------------------------------*
21253 <TC - DECODING [0] EXPLICIT NULL, Short form - short form>
21261 BERPDU ::= [0] EXPLICIT NULL
21263 myNullValue BERPDU ::= NULL
21269 import from TempA all;
21271 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21276 if (dec_BER_PDU('A0020500'O) == myNullValue)
21279 {setverdict(pass);} else {setverdict(fail);}
21284 Overall verdict: pass
21290 .*---------------------------------------------------------------------*
21291 :h3. DECODING [0] EXPLICIT NULL, Long form - short form
21292 .*---------------------------------------------------------------------*
21295 <TC - DECODING [0] EXPLICIT NULL, Long form - short form>
21303 BERPDU ::= [0] EXPLICIT NULL
21305 myNullValue BERPDU ::= NULL
21311 import from TempA all;
21313 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21318 if (dec_BER_PDU('A081020500'O) == myNullValue)
21321 {setverdict(pass);} else {setverdict(fail);}
21326 Overall verdict: pass
21332 .*---------------------------------------------------------------------*
21333 :h3. DECODING [0] EXPLICIT NULL, Long form Long form
21334 .*---------------------------------------------------------------------*
21337 <TC - DECODING [0] EXPLICIT NULL, Long form Long form>
21345 BERPDU ::= [0] EXPLICIT NULL
21347 myNullValue BERPDU ::= NULL
21353 import from TempA all;
21355 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21360 if (dec_BER_PDU('A08103058100'O) == myNullValue)
21363 {setverdict(pass);} else {setverdict(fail);}
21368 Overall verdict: pass
21374 .*---------------------------------------------------------------------*
21375 :h3. DECODING [PRIVATE 1] EXPLICIT NULL , DER
21376 .*---------------------------------------------------------------------*
21379 <TC - DECODING [PRIVATE 1] EXPLICIT NULL , DER>
21387 BERPDU ::= [PRIVATE 1] EXPLICIT NULL
21389 myNullValue BERPDU ::= NULL
21395 import from TempA all;
21397 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21402 if (dec_BER_PDU('E1020500'O) == myNullValue)
21405 {setverdict(pass);} else {setverdict(fail);}
21410 Overall verdict: pass
21416 .*---------------------------------------------------------------------*
21417 :h3. DECODING [PRIVATE 1] EXPLICIT NULL, CER
21418 .*---------------------------------------------------------------------*
21421 <TC - DECODING [PRIVATE 1] EXPLICIT NULL, CER>
21429 BERPDU ::= [PRIVATE 1] EXPLICIT NULL
21431 myNullValue BERPDU ::= NULL
21437 import from TempA all;
21439 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21444 if (dec_BER_PDU('E18005000000'O) == myNullValue)
21447 {setverdict(pass);} else {setverdict(fail);}
21452 Overall verdict: pass
21458 .*---------------------------------------------------------------------*
21459 :h3. DECODING [PRIVATE 1] EXPLICIT NULL, Short form - short form
21460 .*---------------------------------------------------------------------*
21463 <TC - DECODING [PRIVATE 1] EXPLICIT NULL, Short form - short form>
21471 BERPDU ::= [PRIVATE 1] EXPLICIT NULL
21473 myNullValue BERPDU ::= NULL
21479 import from TempA all;
21481 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21486 if (dec_BER_PDU('E1020500'O) == myNullValue)
21489 {setverdict(pass);} else {setverdict(fail);}
21494 Overall verdict: pass
21500 .*---------------------------------------------------------------------*
21501 :h3. DECODING [PRIVATE 1] EXPLICIT NULL, Long form - short form
21502 .*---------------------------------------------------------------------*
21505 <TC - DECODING [PRIVATE 1] EXPLICIT NULL, Long form - short form>
21513 BERPDU ::= [PRIVATE 1] EXPLICIT NULL
21515 myNullValue BERPDU ::= NULL
21521 import from TempA all;
21523 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21528 if (dec_BER_PDU('E181020500'O) == myNullValue)
21531 {setverdict(pass);} else {setverdict(fail);}
21536 Overall verdict: pass
21542 .*---------------------------------------------------------------------*
21543 :h3. DECODING [PRIVATE 1] EXPLICIT NULL, Long form Long form
21544 .*---------------------------------------------------------------------*
21547 <TC - DECODING [PRIVATE 1] EXPLICIT NULL, Long form Long form>
21555 BERPDU ::= [PRIVATE 1] EXPLICIT NULL
21557 myNullValue BERPDU ::= NULL
21563 import from TempA all;
21565 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21570 if (dec_BER_PDU('E18103058100'O) == myNullValue)
21573 {setverdict(pass);} else {setverdict(fail);}
21578 Overall verdict: pass
21584 .*---------------------------------------------------------------------*
21585 :h3. DECODING [APPLICATION 2] EXPLICIT NULL , DER
21586 .*---------------------------------------------------------------------*
21589 <TC - DECODING [APPLICATION 2] EXPLICIT NULL , DER>
21597 BERPDU ::= [APPLICATION 2] EXPLICIT NULL
21599 myNullValue BERPDU ::= NULL
21605 import from TempA all;
21607 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21612 if (dec_BER_PDU('62020500'O) == myNullValue)
21615 {setverdict(pass);} else {setverdict(fail);}
21620 Overall verdict: pass
21626 .*---------------------------------------------------------------------*
21627 :h3. DECODING [APPLICATION 2] EXPLICIT NULL, CER
21628 .*---------------------------------------------------------------------*
21631 <TC - DECODING [APPLICATION 2] EXPLICIT NULL, CER>
21639 BERPDU ::= [APPLICATION 2] EXPLICIT NULL
21641 myNullValue BERPDU ::= NULL
21647 import from TempA all;
21649 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21654 if (dec_BER_PDU('628005000000'O) == myNullValue)
21657 {setverdict(pass);} else {setverdict(fail);}
21662 Overall verdict: pass
21668 .*---------------------------------------------------------------------*
21669 :h3. DECODING [APPLICATION 2] EXPLICIT NULL, Short form - short form
21670 .*---------------------------------------------------------------------*
21673 <TC - DECODING [APPLICATION 2] EXPLICIT NULL, Short form - short form>
21681 BERPDU ::= [APPLICATION 2] EXPLICIT NULL
21683 myNullValue BERPDU ::= NULL
21689 import from TempA all;
21691 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21696 if (dec_BER_PDU('62020500'O) == myNullValue)
21699 {setverdict(pass);} else {setverdict(fail);}
21704 Overall verdict: pass
21710 .*---------------------------------------------------------------------*
21711 :h3. DECODING [APPLICATION 2] EXPLICIT NULL, Long form - short form
21712 .*---------------------------------------------------------------------*
21715 <TC - DECODING [APPLICATION 2] EXPLICIT NULL, Long form - short form>
21723 BERPDU ::= [APPLICATION 2] EXPLICIT NULL
21725 myNullValue BERPDU ::= NULL
21731 import from TempA all;
21733 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21738 if (dec_BER_PDU('6281020500'O) == myNullValue)
21741 {setverdict(pass);} else {setverdict(fail);}
21746 Overall verdict: pass
21752 .*---------------------------------------------------------------------*
21753 :h3. DECODING [APPLICATION 2] EXPLICIT NULL, Long form Long form
21754 .*---------------------------------------------------------------------*
21757 <TC - DECODING [APPLICATION 2] EXPLICIT NULL, Long form Long form>
21765 BERPDU ::= [APPLICATION 2] EXPLICIT NULL
21767 myNullValue BERPDU ::= NULL
21773 import from TempA all;
21775 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21780 if (dec_BER_PDU('628103058100'O) == myNullValue)
21783 {setverdict(pass);} else {setverdict(fail);}
21788 Overall verdict: pass
21794 .*---------------------------------------------------------------------*
21795 :h3. DECODING [0] IMPLICIT NULL ,Short form CER,DER
21796 .*---------------------------------------------------------------------*
21799 <TC - DECODING [0] IMPLICIT NULL ,Short form CER,DER>
21807 BERPDU ::= [0] IMPLICIT NULL
21809 myNullValue BERPDU ::= NULL
21815 import from TempA all;
21817 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21822 if (dec_BER_PDU('8000'O) == myNullValue)
21825 {setverdict(pass);} else {setverdict(fail);}
21830 Overall verdict: pass
21836 .*---------------------------------------------------------------------*
21837 :h3. DECODING [0] IMPLICIT NULL ,Long form
21838 .*---------------------------------------------------------------------*
21841 <TC - DECODING [0] IMPLICIT NULL ,Long form>
21849 BERPDU ::= [0] IMPLICIT NULL
21851 myNullValue BERPDU ::= NULL
21857 import from TempA all;
21859 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21864 if (dec_BER_PDU('808100'O) == myNullValue)
21867 {setverdict(pass);} else {setverdict(fail);}
21872 Overall verdict: pass
21878 .*---------------------------------------------------------------------*
21879 :h3. DECODING [PRIVATE 1] IMPLICIT NULL ,Short form CER,DER
21880 .*---------------------------------------------------------------------*
21883 <TC - DECODING [PRIVATE 1] IMPLICIT NULL ,Short form CER,DER>
21891 BERPDU ::= [PRIVATE 1] IMPLICIT NULL
21893 myNullValue BERPDU ::= NULL
21899 import from TempA all;
21901 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21906 if (dec_BER_PDU('C100'O) == myNullValue)
21909 {setverdict(pass);} else {setverdict(fail);}
21914 Overall verdict: pass
21920 .*---------------------------------------------------------------------*
21921 :h3. DECODING [PRIVATE 1] IMPLICIT NULL ,Long form
21922 .*---------------------------------------------------------------------*
21925 <TC - DECODING [PRIVATE 1] IMPLICIT NULL ,Long form>
21933 BERPDU ::= [PRIVATE 1] IMPLICIT NULL
21935 myNullValue BERPDU ::= NULL
21941 import from TempA all;
21943 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21948 if (dec_BER_PDU('C18100'O) == myNullValue)
21951 {setverdict(pass);} else {setverdict(fail);}
21956 Overall verdict: pass
21962 .*---------------------------------------------------------------------*
21963 :h3. DECODING [APPLICATION 2] IMPLICIT NULL ,Short form CER,DER
21964 .*---------------------------------------------------------------------*
21967 <TC - DECODING [APPLICATION 2] IMPLICIT NULL ,Short form CER,DER>
21975 BERPDU ::= [APPLICATION 2] IMPLICIT NULL
21977 myNullValue BERPDU ::= NULL
21983 import from TempA all;
21985 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21990 if (dec_BER_PDU('4200'O) == myNullValue)
21993 {setverdict(pass);} else {setverdict(fail);}
21998 Overall verdict: pass
22004 .*---------------------------------------------------------------------*
22005 :h3. DECODING [APPLICATION 2] IMPLICIT NULL,Long form
22006 .*---------------------------------------------------------------------*
22009 <TC - DECODING [APPLICATION 2] IMPLICIT NULL,Long form>
22017 BERPDU ::= [APPLICATION 2] IMPLICIT NULL
22019 myNullValue BERPDU ::= NULL
22025 import from TempA all;
22027 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
22032 if (dec_BER_PDU('428100'O) == myNullValue)
22035 {setverdict(pass);} else {setverdict(fail);}
22040 Overall verdict: pass
22046 .*---------------------------------------------------------------------*
22047 :h3.CER + DER encoding of SEQUENCE (EMPTY)
22048 .*---------------------------------------------------------------------*
22051 <TC - CER + DER encoding of SEQUENCE (EMPTY)>
22060 BERPDU ::= SEQUENCE
22062 b BOOLEAN OPTIONAL,
22071 import from TempA all;
22072 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22073 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22075 const BERPDU myValue := {b := omit,
22083 if ((enc_DER_PDU(myValue) == '3000'O)and(enc_CER_PDU(myValue) == '30800000'O)) {setverdict(pass);} else {setverdict(fail);}
22087 Overall verdict: pass
22093 .*---------------------------------------------------------------------*
22094 :h3.CER + DER encoding of SEQUENCE (only one element is used)
22095 .*---------------------------------------------------------------------*
22098 <TC - CER + DER encoding of SEQUENCE (only one element is used)>
22107 BERPDU ::= SEQUENCE
22109 b BOOLEAN OPTIONAL,
22118 import from TempA all;
22119 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22120 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22122 const BERPDU myValue := {b := true,
22130 if ((enc_DER_PDU(myValue) == '30030101FF'O)and(enc_CER_PDU(myValue) == '30800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
22134 Overall verdict: pass
22140 .*---------------------------------------------------------------------*
22141 :h3.CER + DER encoding of SEQUENCE (both elements are used)
22142 .*---------------------------------------------------------------------*
22145 <TC - CER + DER encoding of SEQUENCE (both elements are used)>
22154 BERPDU ::= SEQUENCE
22156 b BOOLEAN OPTIONAL,
22165 import from TempA all;
22166 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22167 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22169 const BERPDU myValue := {b := true,
22177 if ((enc_DER_PDU(myValue) == '30060101FF020105'O)and(enc_CER_PDU(myValue) == '30800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
22181 Overall verdict: pass
22187 .*---------------------------------------------------------------------*
22188 :h3.CER + DER encoding of SEQUENCE (one element is equal to Default)
22189 .*---------------------------------------------------------------------*
22192 <TC - CER + DER encoding of SEQUENCE (one element is equal to Default)>
22201 BERPDU ::= SEQUENCE
22203 b BOOLEAN DEFAULT TRUE,
22212 import from TempA all;
22213 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22214 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22216 const BERPDU myValue := {b := true,
22224 if ((enc_DER_PDU(myValue) == '3003020105'O)and(enc_CER_PDU(myValue) == '30800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
22228 Overall verdict: pass
22234 .*---------------------------------------------------------------------*
22235 :h3.CER + DER encoding of SEQUENCE (one element is not equal to Default)
22236 .*---------------------------------------------------------------------*
22239 <TC - CER + DER encoding of SEQUENCE (one element is not equal to Default)>
22248 BERPDU ::= SEQUENCE
22250 b BOOLEAN DEFAULT TRUE,
22259 import from TempA all;
22260 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22261 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22263 const BERPDU myValue := {b := false,
22271 if ((enc_DER_PDU(myValue) == '3006010100020105'O)and(enc_CER_PDU(myValue) == '30800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);}
22275 Overall verdict: pass
22281 .*---------------------------------------------------------------------*
22282 :h3.CER + DER encoding of SEQUENCE (EMPTY), AUTOMATIC TAGGING
22283 .*---------------------------------------------------------------------*
22286 <TC - CER + DER encoding of SEQUENCE (EMPTY), AUTOMATIC TAGGING>
22300 BERPDU ::= SEQUENCE
22302 b BOOLEAN OPTIONAL,
22311 import from TempA all;
22312 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22313 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22315 const BERPDU myValue := {b := omit,
22323 if ((enc_DER_PDU(myValue) == '3000'O)and(enc_CER_PDU(myValue) == '30800000'O)) {setverdict(pass);} else {setverdict(fail);}
22327 Overall verdict: pass
22333 .*---------------------------------------------------------------------*
22334 :h3.CER + DER encoding of SEQUENCE (only one element is used) AUTOMATIC TAGGING
22335 .*---------------------------------------------------------------------*
22338 <TC - CER + DER encoding of SEQUENCE (only one element is used) AUTOMATIC TAGGING>
22352 BERPDU ::= SEQUENCE
22354 b BOOLEAN OPTIONAL,
22363 import from TempA all;
22364 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22365 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22367 const BERPDU myValue := {b := true,
22375 if ((enc_DER_PDU(myValue) == '30038001FF'O)and(enc_CER_PDU(myValue) == '30808001FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
22379 Overall verdict: pass
22385 .*---------------------------------------------------------------------*
22386 :h3.CER + DER encoding of SEQUENCE (both elements are used) AUTOMATIC TAGGING
22387 .*---------------------------------------------------------------------*
22390 <TC - CER + DER encoding of SEQUENCE (both elements are used) AUTOMATIC TAGGING>
22404 BERPDU ::= SEQUENCE
22406 b BOOLEAN OPTIONAL,
22415 import from TempA all;
22416 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22417 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22419 const BERPDU myValue := {b := true,
22427 if ((enc_DER_PDU(myValue) == '30068001FF810105'O)and(enc_CER_PDU(myValue) == '30808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
22431 Overall verdict: pass
22437 .*---------------------------------------------------------------------*
22438 :h3.CER + DER encoding of SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING
22439 .*---------------------------------------------------------------------*
22442 <TC - CER + DER encoding of SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING>
22456 BERPDU ::= SEQUENCE
22458 b BOOLEAN DEFAULT TRUE,
22467 import from TempA all;
22468 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22469 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22471 const BERPDU myValue := {b := true,
22479 if ((enc_DER_PDU(myValue) == '3003810105'O)and(enc_CER_PDU(myValue) == '30808101050000'O)) {setverdict(pass);} else {setverdict(fail);}
22483 Overall verdict: pass
22489 .*---------------------------------------------------------------------*
22490 :h3.CER + DER encoding of SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING
22491 .*---------------------------------------------------------------------*
22494 <TC - CER + DER encoding of SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING>
22508 BERPDU ::= SEQUENCE
22510 b BOOLEAN DEFAULT TRUE,
22519 import from TempA all;
22520 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22521 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22523 const BERPDU myValue := {b := false,
22531 if ((enc_DER_PDU(myValue) == '3006800100810105'O)and(enc_CER_PDU(myValue) == '30808001008101050000'O)) {setverdict(pass);} else {setverdict(fail);}
22535 Overall verdict: pass
22541 .*---------------------------------------------------------------------*
22542 :h3.CER + DER encoding of SEQUENCE (both elements are used) IMPLICIT TAGS for elements
22543 .*---------------------------------------------------------------------*
22546 <TC - CER + DER encoding of SEQUENCE (both elements are used) IMPLICIT TAGS for elements>
22555 BERPDU ::= SEQUENCE
22557 b [30] IMPLICIT BOOLEAN OPTIONAL,
22558 c [31] IMPLICIT INTEGER OPTIONAL
22566 import from TempA all;
22567 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22568 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22570 const BERPDU myValue := {b := true,
22578 if ((enc_DER_PDU(myValue) == '30079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '30809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
22582 Overall verdict: pass
22588 .*---------------------------------------------------------------------*
22589 :h3.CER + DER encoding of SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
22590 .*---------------------------------------------------------------------*
22593 <TC - CER + DER encoding of SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
22607 BERPDU ::= SEQUENCE
22609 b [30] IMPLICIT BOOLEAN OPTIONAL,
22610 c [31] IMPLICIT INTEGER OPTIONAL
22618 import from TempA all;
22619 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22620 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22622 const BERPDU myValue := {b := true,
22630 if ((enc_DER_PDU(myValue) == '30079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '30809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
22634 Overall verdict: pass
22640 .*---------------------------------------------------------------------*
22641 :h3.CER + DER encoding of SEQUENCE (both elements are used) EXPLICIT TAGS for elements
22642 .*---------------------------------------------------------------------*
22645 <TC - CER + DER encoding of SEQUENCE (both elements are used) EXPLICIT TAGS for elements>
22654 BERPDU ::= SEQUENCE
22656 b [30] EXPLICIT BOOLEAN OPTIONAL,
22657 c [31] EXPLICIT INTEGER OPTIONAL
22665 import from TempA all;
22666 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22667 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22669 const BERPDU myValue := {b := true,
22677 if ((enc_DER_PDU(myValue) == '300BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3080BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
22681 Overall verdict: pass
22687 .*---------------------------------------------------------------------*
22688 :h3.CER + DER encoding of SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
22689 .*---------------------------------------------------------------------*
22692 <TC - CER + DER encoding of SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
22706 BERPDU ::= SEQUENCE
22708 b [30] EXPLICIT BOOLEAN OPTIONAL,
22709 c [31] EXPLICIT INTEGER OPTIONAL
22717 import from TempA all;
22718 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22719 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22721 const BERPDU myValue := {b := true,
22729 if ((enc_DER_PDU(myValue) == '300BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3080BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
22733 Overall verdict: pass
22739 .*---------------------------------------------------------------------*
22740 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are used)
22741 .*---------------------------------------------------------------------*
22744 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are used)>
22753 BERPDU ::= [0] SEQUENCE
22755 b BOOLEAN OPTIONAL,
22764 import from TempA all;
22765 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22766 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22768 const BERPDU myValue := {b := true,
22776 if ((enc_DER_PDU(myValue) == 'A00830060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08030800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
22780 Overall verdict: pass
22786 .*---------------------------------------------------------------------*
22787 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are used), AUTOMATIC TAGGING ENVIRONMENT
22788 .*---------------------------------------------------------------------*
22791 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are used), AUTOMATIC TAGGING ENVIRONMENT>
22805 BERPDU ::= [0] SEQUENCE
22807 b BOOLEAN OPTIONAL,
22816 import from TempA all;
22817 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22818 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22820 const BERPDU myValue := {b := true,
22828 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
22832 Overall verdict: pass
22838 .*---------------------------------------------------------------------*
22839 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT
22840 .*---------------------------------------------------------------------*
22843 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
22857 BERPDU ::= [0] SEQUENCE
22859 b BOOLEAN OPTIONAL,
22868 import from TempA all;
22869 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22870 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22872 const BERPDU myValue := {b := true,
22880 if ((enc_DER_PDU(myValue) == 'A0060101FF020105'O)and(enc_CER_PDU(myValue) == 'A0800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
22884 Overall verdict: pass
22890 .*---------------------------------------------------------------------*
22891 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT
22892 .*---------------------------------------------------------------------*
22895 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
22909 BERPDU ::= [0] SEQUENCE
22911 b BOOLEAN OPTIONAL,
22920 import from TempA all;
22921 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22922 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22924 const BERPDU myValue := {b := true,
22932 if ((enc_DER_PDU(myValue) == 'A00830060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08030800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
22936 Overall verdict: pass
22942 .*---------------------------------------------------------------------*
22943 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used)
22944 .*---------------------------------------------------------------------*
22947 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used)>
22956 BERPDU ::= [0] SEQUENCE
22958 b [0] BOOLEAN OPTIONAL,
22959 c [1] INTEGER OPTIONAL
22967 import from TempA all;
22968 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22969 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22971 const BERPDU myValue := {b := true,
22979 if ((enc_DER_PDU(myValue) == 'A00C300AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803080A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
22983 Overall verdict: pass
22989 .*---------------------------------------------------------------------*
22990 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
22991 .*---------------------------------------------------------------------*
22994 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
23008 BERPDU ::= [0] SEQUENCE
23010 b [0] BOOLEAN OPTIONAL,
23011 c [1] INTEGER OPTIONAL
23019 import from TempA all;
23020 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23021 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23023 const BERPDU myValue := {b := true,
23031 if ((enc_DER_PDU(myValue) == 'A00C300AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803080A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
23035 Overall verdict: pass
23041 .*---------------------------------------------------------------------*
23042 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
23043 .*---------------------------------------------------------------------*
23046 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
23060 BERPDU ::= [0] SEQUENCE
23062 b [0] BOOLEAN OPTIONAL,
23063 c [1] INTEGER OPTIONAL
23071 import from TempA all;
23072 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23073 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23075 const BERPDU myValue := {b := true,
23083 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
23087 Overall verdict: pass
23093 .*---------------------------------------------------------------------*
23094 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
23095 .*---------------------------------------------------------------------*
23098 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
23112 BERPDU ::= [0] SEQUENCE
23114 b [0] BOOLEAN OPTIONAL,
23115 c [1] INTEGER OPTIONAL
23123 import from TempA all;
23124 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23125 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23127 const BERPDU myValue := {b := true,
23135 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
23139 Overall verdict: pass
23145 .*---------------------------------------------------------------------*
23146 :h3.CER + DER encoding of SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
23147 .*---------------------------------------------------------------------*
23150 <TC - CER + DER encoding of SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
23164 BERPDU ::= SEQUENCE
23166 b [5] BOOLEAN OPTIONAL,
23175 import from TempA all;
23176 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23177 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23179 const BERPDU myValue := {b := true,
23187 if ((enc_DER_PDU(myValue) == '30068501FF020105'O)and(enc_CER_PDU(myValue) == '30808501FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
23191 Overall verdict: pass
23197 .*---------------------------------------------------------------------*
23198 :h3.CER + DER encoding of SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
23199 .*---------------------------------------------------------------------*
23202 <TC - CER + DER encoding of SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
23218 {x INTEGER OPTIONAL,
23223 BERPDU ::= SEQUENCE
23225 b BOOLEAN OPTIONAL,
23226 c INTEGER OPTIONAL,
23227 COMPONENTS OF MySeq
23235 import from TempA all;
23236 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23237 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23239 const BERPDU myValue := {b := true,
23249 if ((enc_DER_PDU(myValue) == '300C8001FF8101058201068301FF'O)and(enc_CER_PDU(myValue) == '30808001FF8101058201068301FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
23253 Overall verdict: pass
23259 .*---------------------------------------------------------------------*
23260 :h3.CER + DER encoding of SEQUENCE , one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
23261 .*---------------------------------------------------------------------*
23264 <TC - CER + DER encoding of SEQUENCE , one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
23279 {x [0] INTEGER OPTIONAL,
23284 BERPDU ::= SEQUENCE
23286 b BOOLEAN OPTIONAL,
23287 c INTEGER OPTIONAL,
23288 COMPONENTS OF MySeq
23296 import from TempA all;
23297 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23298 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23300 const BERPDU myValue := {b := true,
23310 if ((enc_DER_PDU(myValue) == '300C8001FF8101058201068301FF'O)and(enc_CER_PDU(myValue) == '30808001FF8101058201068301FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
23314 Overall verdict: pass
23320 .*---------------------------------------------------------------------*
23321 :h3.CER + DER encoding of SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
23322 .*---------------------------------------------------------------------*
23325 <TC - CER + DER encoding of SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
23341 {x INTEGER OPTIONAL,
23346 BERPDU ::= SEQUENCE
23348 b [0] BOOLEAN OPTIONAL,
23349 c BIT STRING OPTIONAL,
23350 COMPONENTS OF MySeq
23358 import from TempA all;
23359 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23360 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23362 const BERPDU myValue := {b := true,
23372 if ((enc_DER_PDU(myValue) == '300D8001FF030207800201060401FF'O)and(enc_CER_PDU(myValue) == '30808001FF030207800201060401FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
23376 Overall verdict: pass
23382 .*---------------------------------------------------------------------*
23383 :h3.CER + DER encoding of SEQUENCE , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
23384 .*---------------------------------------------------------------------*
23387 <TC - CER + DER encoding of SEQUENCE , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
23402 {x [1] INTEGER OPTIONAL,
23407 BERPDU ::= SEQUENCE
23409 b [0] BOOLEAN OPTIONAL,
23410 c BIT STRING OPTIONAL,
23411 COMPONENTS OF MySeq
23420 import from TempA all;
23421 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23422 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23424 const BERPDU myValue := {b := true,
23434 if ((enc_DER_PDU(myValue) == '300D8001FF030207808101060401FF'O)and(enc_CER_PDU(myValue) == '30808001FF030207808101060401FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
23438 Overall verdict: pass
23444 .*---------------------------------------------------------------------*
23445 :h3.CER + DER encoding of SEQUENCE with CHOICE element, AUTOMATIC TAGS
23446 .*---------------------------------------------------------------------*
23449 <TC - CER + DER encoding of SEQUENCE with CHOICE element, AUTOMATIC TAGS>
23466 BERPDU ::= SEQUENCE
23485 import from TempA all;
23486 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23487 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23489 const BERPDU myValue := {b := {x := true},
23497 if ((enc_DER_PDU(myValue) == '3008A0038001FF810104'O)and(enc_CER_PDU(myValue) == '3080A0808001FF00008101040000'O)) {setverdict(pass);} else {setverdict(fail);}
23501 Overall verdict: pass
23507 .*---------------------------------------------------------------------*
23508 :h3.CER + DER encoding of SEQUENCE with CHOICE element,
23509 .*---------------------------------------------------------------------*
23512 <TC - CER + DER encoding of SEQUENCE with CHOICE element, >
23529 BERPDU ::= SEQUENCE
23548 import from TempA all;
23549 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23550 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23552 const BERPDU myValue := {b := {x := true},
23560 if ((enc_DER_PDU(myValue) == '30060101FF020104'O)and(enc_CER_PDU(myValue) == '30800101FF0201040000'O)) {setverdict(pass);} else {setverdict(fail);}
23564 Overall verdict: pass
23570 .*---------------------------------------------------------------------*
23571 :h3.CER + DER encoding of SEQUENCE with EXTENSION , AUTOMATIC TAGS
23572 .*---------------------------------------------------------------------*
23575 <TC - CER + DER encoding of SEQUENCE with EXTENSION , AUTOMATIC TAGS>
23592 BERPDU ::= SEQUENCE
23614 import from TempA all;
23615 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23616 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23618 const BERPDU myValue := {
23629 if ((enc_DER_PDU(myValue) == '300D8001FF8101FF83020780820104'O)and(enc_CER_PDU(myValue) == '30808001FF8101FF830207808201040000'O)) {setverdict(pass);} else {setverdict(fail);}
23633 Overall verdict: pass
23639 .*---------------------------------------------------------------------*
23640 :h3.CER + DER encoding of SEQUENCE with fields of different types
23641 .*---------------------------------------------------------------------*
23644 <TC - CER + DER encoding of SEQUENCE with fields of different types>
23653 BERPDU ::= SEQUENCE
23658 d ENUMERATED {first ,second ,third},
23663 h OBJECT IDENTIFIER,
23665 j CHOICE {x1 [1] BOOLEAN,
23666 y1 [2] OCTET STRING},
23668 k SEQUENCE{x2 NULL,
23671 l SET { x3 BIT STRING,
23674 m [3] SEQUENCE OF INTEGER,
23675 n [4] SET OF BOOLEAN
23679 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
23686 import from TempA all;
23687 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23688 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23690 const BERPDU myValue := {a := NULL,
23699 j := {x1 := true } ,
23727 if ((enc_DER_PDU(myValue) == '305305000101FF0201020A0100090603312E452B30030207800402FFFF06030002031603414243A1030101FF300505000101FF310C03020780090603312E452B30A3083006020101020102A40831060101FF0101FF'O)and(enc_CER_PDU(myValue) == '308005000101FF0201020A0100090603312E452B30030207800402FFFF06030002031603414243A1800101FF0000308005000101FF0000318003020780090603312E452B300000A380308002010102010200000000A48031800101FF0101FF000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
23731 Overall verdict: pass
23737 .*---------------------------------------------------------------------*
23738 :h3.CER + DER encoding of SEQUENCE with fields of different types, AUTOMATIC TAGS
23739 .*---------------------------------------------------------------------*
23742 <TC - CER + DER encoding of SEQUENCE with fields of different types, AUTOMATIC TAGS>
23756 BERPDU ::= SEQUENCE
23761 d ENUMERATED {first ,second ,third},
23766 h OBJECT IDENTIFIER,
23768 j CHOICE {x1 BOOLEAN,
23771 k SEQUENCE{x2 NULL,
23774 l SET { x3 BIT STRING,
23777 m SEQUENCE OF INTEGER,
23782 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
23789 import from TempA all;
23790 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23791 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23793 const BERPDU myValue := {a := NULL,
23802 j := {x1 := true } ,
23830 if ((enc_DER_PDU(myValue) == '304F80008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB0C80020780810603312E452B30AC06020101020102AD060101FF0101FF'O)and(enc_CER_PDU(myValue) == '308080008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB8080020780810603312E452B300000AC800201010201020000AD800101FF0101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
23834 Overall verdict: pass
23840 .*---------------------------------------------------------------------*
23841 :h3. DECODING DER , SEQUENCE (EMPTY)
23842 .*---------------------------------------------------------------------*
23845 <TC - DECODING DER , SEQUENCE (EMPTY)>
23853 BERPDU ::= SEQUENCE
23855 b BOOLEAN OPTIONAL,
23863 import from TempA all;
23865 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
23868 const BERPDU myValue := {b := omit,
23873 if (dec_BER_PDU('3000'O) == myValue)
23877 {setverdict(pass);} else {setverdict(fail);}
23882 Overall verdict: pass
23888 .*---------------------------------------------------------------------*
23889 :h3. DECODING CER , SEQUENCE (EMPTY)
23890 .*---------------------------------------------------------------------*
23893 <TC - DECODING CER , SEQUENCE (EMPTY)>
23901 BERPDU ::= SEQUENCE
23903 b BOOLEAN OPTIONAL,
23911 import from TempA all;
23913 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
23916 const BERPDU myValue := {b := omit,
23921 if (dec_BER_PDU('30800000'O) == myValue)
23925 {setverdict(pass);} else {setverdict(fail);}
23930 Overall verdict: pass
23936 .*---------------------------------------------------------------------*
23937 :h3.DECODING DER , SEQUENCE (only one element is used)
23938 .*---------------------------------------------------------------------*
23941 <TC - DECODING DER , SEQUENCE (only one element is used)>
23949 BERPDU ::= SEQUENCE
23951 b BOOLEAN OPTIONAL,
23960 import from TempA all;
23962 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
23965 const BERPDU myValue := {b := true,
23970 if (dec_BER_PDU('30030101FF'O) == myValue)
23974 {setverdict(pass);} else {setverdict(fail);}
23979 Overall verdict: pass
23985 .*---------------------------------------------------------------------*
23986 :h3.DECODING CER , SEQUENCE (only one element is used)
23987 .*---------------------------------------------------------------------*
23990 <TC - DECODING CER , SEQUENCE (only one element is used)>
23998 BERPDU ::= SEQUENCE
24000 b BOOLEAN OPTIONAL,
24009 import from TempA all;
24011 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24014 const BERPDU myValue := {b := true,
24019 if (dec_BER_PDU('30800101FF0000'O) == myValue)
24023 {setverdict(pass);} else {setverdict(fail);}
24028 Overall verdict: pass
24034 .*---------------------------------------------------------------------*
24035 :h3. DECODING DER , SEQUENCE (both elements are used)
24036 .*---------------------------------------------------------------------*
24039 <TC - DECODING DER , SEQUENCE (both elements are used)>
24047 BERPDU ::= SEQUENCE
24049 b BOOLEAN OPTIONAL,
24058 import from TempA all;
24060 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24063 const BERPDU myValue := {b := true,
24069 if (dec_BER_PDU('30060101FF020105'O) == myValue)
24073 {setverdict(pass);} else {setverdict(fail);}
24078 Overall verdict: pass
24084 .*---------------------------------------------------------------------*
24085 :h3. DECODING DER , SEQUENCE (both elements are used)
24086 .*---------------------------------------------------------------------*
24089 <TC - DECODING DER , SEQUENCE (both elements are used)>
24097 BERPDU ::= SEQUENCE
24099 b BOOLEAN OPTIONAL,
24108 import from TempA all;
24110 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24113 const BERPDU myValue := {b := true,
24119 if (dec_BER_PDU('30800101FF0201050000'O) == myValue)
24123 {setverdict(pass);} else {setverdict(fail);}
24128 Overall verdict: pass
24134 .*---------------------------------------------------------------------*
24135 :h3. DECODING DER , SEQUENCE (one element is equal to Default)
24136 .*---------------------------------------------------------------------*
24139 <TC - DECODING DER , SEQUENCE (one element is equal to Default)>
24147 BERPDU ::= SEQUENCE
24149 b BOOLEAN DEFAULT TRUE,
24157 import from TempA all;
24159 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24162 const BERPDU myValue := {b := true,
24166 if (dec_BER_PDU('3003020105'O) == myValue)
24170 {setverdict(pass);} else {setverdict(fail);}
24175 Overall verdict: pass
24181 .*---------------------------------------------------------------------*
24182 :h3. DECODING CER, SEQUENCE (one element is equal to Default)
24183 .*---------------------------------------------------------------------*
24186 <TC - DECODING CER, SEQUENCE (one element is equal to Default)>
24194 BERPDU ::= SEQUENCE
24196 b BOOLEAN DEFAULT TRUE,
24204 import from TempA all;
24206 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24209 const BERPDU myValue := {b := true,
24213 if (dec_BER_PDU('30800201050000'O) == myValue)
24217 {setverdict(pass);} else {setverdict(fail);}
24222 Overall verdict: pass
24228 .*---------------------------------------------------------------------*
24229 :h3. DECODING DER , SEQUENCE (one element is not equal to Default)
24230 .*---------------------------------------------------------------------*
24233 <TC - DECODING DER , SEQUENCE (one element is not equal to Default)>
24242 BERPDU ::= SEQUENCE
24244 b BOOLEAN DEFAULT TRUE,
24253 import from TempA all;
24255 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24258 const BERPDU myValue := {b := false,
24262 if (dec_BER_PDU('3006010100020105'O) == myValue)
24266 {setverdict(pass);} else {setverdict(fail);}
24271 Overall verdict: pass
24277 .*---------------------------------------------------------------------*
24278 :h3. DECODING CER , SEQUENCE (one element is not equal to Default)
24279 .*---------------------------------------------------------------------*
24282 <TC - DECODING CER , SEQUENCE (one element is not equal to Default)>
24291 BERPDU ::= SEQUENCE
24293 b BOOLEAN DEFAULT TRUE,
24302 import from TempA all;
24304 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24307 const BERPDU myValue := {b := false,
24311 if (dec_BER_PDU('30800101000201050000'O) == myValue)
24315 {setverdict(pass);} else {setverdict(fail);}
24320 Overall verdict: pass
24326 .*---------------------------------------------------------------------*
24327 :h3. DECODING DER , SEQUENCE (EMPTY), AUTOMATIC TAGGING
24328 .*---------------------------------------------------------------------*
24331 <TC - DECODING DER , SEQUENCE (EMPTY), AUTOMATIC TAGGING>
24346 BERPDU ::= SEQUENCE
24348 b BOOLEAN OPTIONAL,
24357 import from TempA all;
24359 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24362 const BERPDU myValue := {b := omit,
24367 if (dec_BER_PDU('3000'O) == myValue)
24371 {setverdict(pass);} else {setverdict(fail);}
24376 Overall verdict: pass
24382 .*---------------------------------------------------------------------*
24383 :h3. DECODING CER , SEQUENCE (EMPTY), AUTOMATIC TAGGING
24384 .*---------------------------------------------------------------------*
24387 <TC - DECODING CER , SEQUENCE (EMPTY), AUTOMATIC TAGGING>
24402 BERPDU ::= SEQUENCE
24404 b BOOLEAN OPTIONAL,
24413 import from TempA all;
24415 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24418 const BERPDU myValue := {b := omit,
24423 if (dec_BER_PDU('30800000'O) == myValue)
24427 {setverdict(pass);} else {setverdict(fail);}
24432 Overall verdict: pass
24438 .*---------------------------------------------------------------------*
24439 :h3. DECODING DER , SEQUENCE (only one element is used) AUTOMATIC TAGGING
24440 .*---------------------------------------------------------------------*
24443 <TC - DECODING DER , SEQUENCE (only one element is used) AUTOMATIC TAGGING>
24459 BERPDU ::= SEQUENCE
24461 b BOOLEAN OPTIONAL,
24470 import from TempA all;
24472 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24475 const BERPDU myValue := {b := true,
24480 if (dec_BER_PDU('30038001FF'O) == myValue)
24484 {setverdict(pass);} else {setverdict(fail);}
24489 Overall verdict: pass
24495 .*---------------------------------------------------------------------*
24496 :h3. DECODING CER , SEQUENCE (only one element is used) AUTOMATIC TAGGING
24497 .*---------------------------------------------------------------------*
24500 <TC - DECODING CER , SEQUENCE (only one element is used) AUTOMATIC TAGGING>
24516 BERPDU ::= SEQUENCE
24518 b BOOLEAN OPTIONAL,
24527 import from TempA all;
24529 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24532 const BERPDU myValue := {b := true,
24537 if (dec_BER_PDU('30808001FF0000'O) == myValue)
24541 {setverdict(pass);} else {setverdict(fail);}
24546 Overall verdict: pass
24552 .*---------------------------------------------------------------------*
24553 :h3. DECODING DER , SEQUENCE (both elements are used) AUTOMATIC TAGGING
24554 .*---------------------------------------------------------------------*
24557 <TC - DECODING DER , SEQUENCE (both elements are used) AUTOMATIC TAGGING>
24573 BERPDU ::= SEQUENCE
24575 b BOOLEAN OPTIONAL,
24585 import from TempA all;
24587 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24590 const BERPDU myValue := {b := true,
24595 if (dec_BER_PDU('30068001FF810105'O) == myValue)
24599 {setverdict(pass);} else {setverdict(fail);}
24604 Overall verdict: pass
24610 .*---------------------------------------------------------------------*
24611 :h3. DECODING CER , SEQUENCE (both elements are used) AUTOMATIC TAGGING
24612 .*---------------------------------------------------------------------*
24615 <TC - DECODING CER , SEQUENCE (both elements are used) AUTOMATIC TAGGING>
24631 BERPDU ::= SEQUENCE
24633 b BOOLEAN OPTIONAL,
24643 import from TempA all;
24645 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24648 const BERPDU myValue := {b := true,
24653 if (dec_BER_PDU('30808001FF8101050000'O) == myValue)
24657 {setverdict(pass);} else {setverdict(fail);}
24662 Overall verdict: pass
24668 .*---------------------------------------------------------------------*
24669 :h3. DECODING DER , SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING
24670 .*---------------------------------------------------------------------*
24673 <TC - DECODING DER , SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING >
24689 BERPDU ::= SEQUENCE
24691 b BOOLEAN DEFAULT TRUE,
24701 import from TempA all;
24703 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24706 const BERPDU myValue := {b := true,
24711 if (dec_BER_PDU('3003810105'O) == myValue)
24715 {setverdict(pass);} else {setverdict(fail);}
24720 Overall verdict: pass
24726 .*---------------------------------------------------------------------*
24727 :h3. DECODING CER , SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING
24728 .*---------------------------------------------------------------------*
24731 <TC - DECODING CER , SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING >
24747 BERPDU ::= SEQUENCE
24749 b BOOLEAN DEFAULT TRUE,
24759 import from TempA all;
24761 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24764 const BERPDU myValue := {b := true,
24769 if (dec_BER_PDU('30808101050000'O) == myValue)
24773 {setverdict(pass);} else {setverdict(fail);}
24778 Overall verdict: pass
24784 .*---------------------------------------------------------------------*
24785 :h3. DECODING DER ,SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING
24786 .*---------------------------------------------------------------------*
24789 <TC - DECODING DER ,SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING>
24805 BERPDU ::= SEQUENCE
24807 b BOOLEAN DEFAULT TRUE,
24817 import from TempA all;
24819 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24822 const BERPDU myValue := {b := false,
24827 if (dec_BER_PDU('3006800100810105'O) == myValue)
24831 {setverdict(pass);} else {setverdict(fail);}
24836 Overall verdict: pass
24842 .*---------------------------------------------------------------------*
24843 :h3. DECODING CER ,SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING
24844 .*---------------------------------------------------------------------*
24847 <TC - DECODING CER ,SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING>
24863 BERPDU ::= SEQUENCE
24865 b BOOLEAN DEFAULT TRUE,
24875 import from TempA all;
24877 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24880 const BERPDU myValue := {b := false,
24885 if (dec_BER_PDU('30808001008101050000'O) == myValue)
24889 {setverdict(pass);} else {setverdict(fail);}
24894 Overall verdict: pass
24900 .*---------------------------------------------------------------------*
24901 :h3. DECODING DER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements
24902 .*---------------------------------------------------------------------*
24905 <TC - DECODING DER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements>
24921 BERPDU ::= SEQUENCE
24923 b [30] IMPLICIT BOOLEAN OPTIONAL,
24924 c [31] IMPLICIT INTEGER OPTIONAL
24932 import from TempA all;
24934 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24937 const BERPDU myValue := {b := true,
24942 if (dec_BER_PDU('30079E01FF9F1F0105'O) == myValue)
24946 {setverdict(pass);} else {setverdict(fail);}
24951 Overall verdict: pass
24957 .*---------------------------------------------------------------------*
24958 :h3. DECODING CER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements
24959 .*---------------------------------------------------------------------*
24962 <TC - DECODING CER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements>
24978 BERPDU ::= SEQUENCE
24980 b [30] IMPLICIT BOOLEAN OPTIONAL,
24981 c [31] IMPLICIT INTEGER OPTIONAL
24989 import from TempA all;
24991 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24994 const BERPDU myValue := {b := true,
24999 if (dec_BER_PDU('30809E01FF9F1F01050000'O) == myValue)
25003 {setverdict(pass);} else {setverdict(fail);}
25008 Overall verdict: pass
25014 .*---------------------------------------------------------------------*
25015 :h3. DECODING DER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
25016 .*---------------------------------------------------------------------*
25019 <TC - DECODING DER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
25035 BERPDU ::= SEQUENCE
25037 b [30] IMPLICIT BOOLEAN OPTIONAL,
25038 c [31] IMPLICIT INTEGER OPTIONAL
25047 import from TempA all;
25049 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25052 const BERPDU myValue := {b := true,
25058 if (dec_BER_PDU('30079E01FF9F1F0105'O) == myValue)
25062 {setverdict(pass);} else {setverdict(fail);}
25067 Overall verdict: pass
25073 .*---------------------------------------------------------------------*
25074 :h3. DECODING CER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
25075 .*---------------------------------------------------------------------*
25078 <TC - DECODING CER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
25094 BERPDU ::= SEQUENCE
25096 b [30] IMPLICIT BOOLEAN OPTIONAL,
25097 c [31] IMPLICIT INTEGER OPTIONAL
25106 import from TempA all;
25108 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25111 const BERPDU myValue := {b := true,
25117 if (dec_BER_PDU('30809E01FF9F1F01050000'O) == myValue)
25121 {setverdict(pass);} else {setverdict(fail);}
25126 Overall verdict: pass
25132 .*---------------------------------------------------------------------*
25133 :h3. DECODING DER, SEQUENCE (both elements are used) EXPLICIT TAGS for elements
25134 .*---------------------------------------------------------------------*
25137 <TC - DECODING DER, SEQUENCE (both elements are used) EXPLICIT TAGS for elements>
25152 BERPDU ::= SEQUENCE
25154 b [30] EXPLICIT BOOLEAN OPTIONAL,
25155 c [31] EXPLICIT INTEGER OPTIONAL
25164 import from TempA all;
25166 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25169 const BERPDU myValue := {b := true,
25175 if (dec_BER_PDU('300BBE030101FFBF1F03020105'O) == myValue)
25179 {setverdict(pass);} else {setverdict(fail);}
25184 Overall verdict: pass
25190 .*---------------------------------------------------------------------*
25191 :h3. DECODING CER, SEQUENCE (both elements are used) EXPLICIT TAGS for elements
25192 .*---------------------------------------------------------------------*
25195 <TC - DECODING CER, SEQUENCE (both elements are used) EXPLICIT TAGS for elements>
25210 BERPDU ::= SEQUENCE
25212 b [30] EXPLICIT BOOLEAN OPTIONAL,
25213 c [31] EXPLICIT INTEGER OPTIONAL
25222 import from TempA all;
25224 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25227 const BERPDU myValue := {b := true,
25233 if (dec_BER_PDU('3080BE800101FF0000BF1F8002010500000000'O) == myValue)
25237 {setverdict(pass);} else {setverdict(fail);}
25242 Overall verdict: pass
25248 .*---------------------------------------------------------------------*
25249 :h3. DECODING DER , SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
25250 .*---------------------------------------------------------------------*
25253 <TC - DECODING DER , SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
25269 BERPDU ::= SEQUENCE
25271 b [30] EXPLICIT BOOLEAN OPTIONAL,
25272 c [31] EXPLICIT INTEGER OPTIONAL
25280 import from TempA all;
25282 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25285 const BERPDU myValue := {b := true,
25292 if (dec_BER_PDU('300BBE030101FFBF1F03020105'O) == myValue)
25296 {setverdict(pass);} else {setverdict(fail);}
25301 Overall verdict: pass
25307 .*---------------------------------------------------------------------*
25308 :h3. DECODING CER , SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
25309 .*---------------------------------------------------------------------*
25312 <TC - DECODING CER , SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
25328 BERPDU ::= SEQUENCE
25330 b [30] EXPLICIT BOOLEAN OPTIONAL,
25331 c [31] EXPLICIT INTEGER OPTIONAL
25339 import from TempA all;
25341 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25344 const BERPDU myValue := {b := true,
25351 if (dec_BER_PDU('3080BE800101FF0000BF1F8002010500000000'O) == myValue)
25355 {setverdict(pass);} else {setverdict(fail);}
25360 Overall verdict: pass
25366 .*---------------------------------------------------------------------*
25367 :h3. DECODING , DER , TAGGED SEQUENCE (both elements are used)
25368 .*---------------------------------------------------------------------*
25371 <TC - DECODING , DER , TAGGED SEQUENCE (both elements are used)>
25386 BERPDU ::= [0] SEQUENCE
25388 b BOOLEAN OPTIONAL,
25397 import from TempA all;
25399 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25402 const BERPDU myValue := {b := true,
25409 if (dec_BER_PDU('A00830060101FF020105'O) == myValue)
25413 {setverdict(pass);} else {setverdict(fail);}
25418 Overall verdict: pass
25424 .*---------------------------------------------------------------------*
25425 :h3. DECODING , CER , TAGGED SEQUENCE (both elements are used)
25426 .*---------------------------------------------------------------------*
25429 <TC - DECODING , CER , TAGGED SEQUENCE (both elements are used)>
25444 BERPDU ::= [0] SEQUENCE
25446 b BOOLEAN OPTIONAL,
25455 import from TempA all;
25457 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25460 const BERPDU myValue := {b := true,
25467 if (dec_BER_PDU('A08030800101FF02010500000000'O) == myValue)
25471 {setverdict(pass);} else {setverdict(fail);}
25476 Overall verdict: pass
25482 .*---------------------------------------------------------------------*
25483 :h3. DECODING DER , TAGGED SEQUENCE (both elements are used)
25484 .*---------------------------------------------------------------------*
25487 <TC - DECODING DER , TAGGED SEQUENCE (both elements are used)>
25502 BERPDU ::= [0] SEQUENCE
25504 b BOOLEAN OPTIONAL,
25512 import from TempA all;
25514 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25517 const BERPDU myValue := {b := true,
25524 if (dec_BER_PDU('A00830060101FF020105'O) == myValue)
25528 {setverdict(pass);} else {setverdict(fail);}
25533 Overall verdict: pass
25539 .*---------------------------------------------------------------------*
25540 :h3. DECODING CER , TAGGED SEQUENCE (both elements are used)
25541 .*---------------------------------------------------------------------*
25544 <TC - DECODING CER , TAGGED SEQUENCE (both elements are used)>
25559 BERPDU ::= [0] SEQUENCE
25561 b BOOLEAN OPTIONAL,
25569 import from TempA all;
25571 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25574 const BERPDU myValue := {b := true,
25581 if (dec_BER_PDU('A08030800101FF02010500000000'O) == myValue)
25585 {setverdict(pass);} else {setverdict(fail);}
25590 Overall verdict: pass
25596 .*---------------------------------------------------------------------*
25597 :h3. DECODING DER , TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT
25598 .*---------------------------------------------------------------------*
25601 <TC - DECODING DER , TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
25617 BERPDU ::= [0] SEQUENCE
25619 b BOOLEAN OPTIONAL,
25628 import from TempA all;
25630 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25633 const BERPDU myValue := {b := true,
25639 if (dec_BER_PDU('A0060101FF020105'O) == myValue)
25643 {setverdict(pass);} else {setverdict(fail);}
25648 Overall verdict: pass
25654 .*---------------------------------------------------------------------*
25655 :h3. DECODING CER , TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT
25656 .*---------------------------------------------------------------------*
25659 <TC - DECODING CER , TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
25675 BERPDU ::= [0] SEQUENCE
25677 b BOOLEAN OPTIONAL,
25686 import from TempA all;
25688 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25691 const BERPDU myValue := {b := true,
25697 if (dec_BER_PDU('A0800101FF0201050000'O) == myValue)
25701 {setverdict(pass);} else {setverdict(fail);}
25706 Overall verdict: pass
25712 .*---------------------------------------------------------------------*
25713 :h3. DECODING DER , TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT
25714 .*---------------------------------------------------------------------*
25717 <TC - DECODING DER , TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
25733 BERPDU ::= [0] SEQUENCE
25735 b BOOLEAN OPTIONAL,
25744 import from TempA all;
25746 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25749 const BERPDU myValue := {b := true,
25756 if (dec_BER_PDU('A00830060101FF020105'O) == myValue)
25760 {setverdict(pass);} else {setverdict(fail);}
25765 Overall verdict: pass
25771 .*---------------------------------------------------------------------*
25772 :h3. DECODING CER , TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT
25773 .*---------------------------------------------------------------------*
25776 <TC - DECODING CER , TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
25792 BERPDU ::= [0] SEQUENCE
25794 b BOOLEAN OPTIONAL,
25803 import from TempA all;
25805 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25808 const BERPDU myValue := {b := true,
25815 if (dec_BER_PDU('A08030800101FF02010500000000'O) == myValue)
25819 {setverdict(pass);} else {setverdict(fail);}
25824 Overall verdict: pass
25830 .*---------------------------------------------------------------------*
25831 :h3. DECODING DER, TAGGED SEQUENCE (both elements are TAGGED and used)
25832 .*---------------------------------------------------------------------*
25835 <TC - DECODING DER, TAGGED SEQUENCE (both elements are TAGGED and used)>
25850 BERPDU ::= [0] SEQUENCE
25852 b [0] BOOLEAN OPTIONAL,
25853 c [1] INTEGER OPTIONAL
25862 import from TempA all;
25864 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25867 const BERPDU myValue := {b := true,
25874 if (dec_BER_PDU('A00C300AA0030101FFA103020105'O) == myValue)
25878 {setverdict(pass);} else {setverdict(fail);}
25883 Overall verdict: pass
25889 .*---------------------------------------------------------------------*
25890 :h3. DECODING CER, TAGGED SEQUENCE (both elements are TAGGED and used)
25891 .*---------------------------------------------------------------------*
25894 <TC - DECODING CER, TAGGED SEQUENCE (both elements are TAGGED and used)>
25909 BERPDU ::= [0] SEQUENCE
25911 b [0] BOOLEAN OPTIONAL,
25912 c [1] INTEGER OPTIONAL
25921 import from TempA all;
25923 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25926 const BERPDU myValue := {b := true,
25933 if (dec_BER_PDU('A0803080A0800101FF0000A180020105000000000000'O) == myValue)
25937 {setverdict(pass);} else {setverdict(fail);}
25942 Overall verdict: pass
25948 .*---------------------------------------------------------------------*
25949 :h3. DECODING DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
25950 .*---------------------------------------------------------------------*
25953 <TC - DECODING DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
25969 BERPDU ::= [0] SEQUENCE
25971 b [0] BOOLEAN OPTIONAL,
25972 c [1] INTEGER OPTIONAL
25980 import from TempA all;
25982 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25985 const BERPDU myValue := {b := true,
25992 if (dec_BER_PDU('A00C300AA0030101FFA103020105'O) == myValue)
25996 {setverdict(pass);} else {setverdict(fail);}
26001 Overall verdict: pass
26007 .*---------------------------------------------------------------------*
26008 :h3. DECODING CER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
26009 .*---------------------------------------------------------------------*
26012 <TC - DECODING CER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
26028 BERPDU ::= [0] SEQUENCE
26030 b [0] BOOLEAN OPTIONAL,
26031 c [1] INTEGER OPTIONAL
26039 import from TempA all;
26041 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26044 const BERPDU myValue := {b := true,
26051 if (dec_BER_PDU('A0803080A0800101FF0000A180020105000000000000'O) == myValue)
26055 {setverdict(pass);} else {setverdict(fail);}
26060 Overall verdict: pass
26066 .*---------------------------------------------------------------------*
26067 :h3. DECODING , DER , TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
26068 .*---------------------------------------------------------------------*
26071 <TC - DECODING , DER , TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
26087 BERPDU ::= [0] SEQUENCE
26089 b [0] BOOLEAN OPTIONAL,
26090 c [1] INTEGER OPTIONAL
26098 import from TempA all;
26100 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26103 const BERPDU myValue := {b := true,
26109 if (dec_BER_PDU('A0068001FF810105'O) == myValue)
26113 {setverdict(pass);} else {setverdict(fail);}
26118 Overall verdict: pass
26124 .*---------------------------------------------------------------------*
26125 :h3. DECODING , CER , TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
26126 .*---------------------------------------------------------------------*
26129 <TC - DECODING , CER , TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
26145 BERPDU ::= [0] SEQUENCE
26147 b [0] BOOLEAN OPTIONAL,
26148 c [1] INTEGER OPTIONAL
26156 import from TempA all;
26158 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26161 const BERPDU myValue := {b := true,
26167 if (dec_BER_PDU('A0808001FF8101050000'O) == myValue)
26171 {setverdict(pass);} else {setverdict(fail);}
26176 Overall verdict: pass
26182 .*---------------------------------------------------------------------*
26183 :h3. DECODING , DER , TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
26184 .*---------------------------------------------------------------------*
26187 <TC - DECODING , DER , TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
26203 BERPDU ::= [0] SEQUENCE
26205 b [0] BOOLEAN OPTIONAL,
26206 c [1] INTEGER OPTIONAL
26214 import from TempA all;
26216 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26219 const BERPDU myValue := {b := true,
26225 if (dec_BER_PDU('A0068001FF810105'O) == myValue)
26229 {setverdict(pass);} else {setverdict(fail);}
26234 Overall verdict: pass
26240 .*---------------------------------------------------------------------*
26241 :h3. DECODING , CER , TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
26242 .*---------------------------------------------------------------------*
26245 <TC - DECODING , CER , TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
26261 BERPDU ::= [0] SEQUENCE
26263 b [0] BOOLEAN OPTIONAL,
26264 c [1] INTEGER OPTIONAL
26272 import from TempA all;
26274 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26277 const BERPDU myValue := {b := true,
26283 if (dec_BER_PDU('A0808001FF8101050000'O) == myValue)
26287 {setverdict(pass);} else {setverdict(fail);}
26292 Overall verdict: pass
26298 .*---------------------------------------------------------------------*
26299 :h3. DECODING ,DER, SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
26300 .*---------------------------------------------------------------------*
26303 <TC - DECODING ,DER, SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
26319 BERPDU ::= SEQUENCE
26321 b [5] BOOLEAN OPTIONAL,
26330 import from TempA all;
26332 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26335 const BERPDU myValue := {b := true,
26341 if (dec_BER_PDU('30068501FF020105'O) == myValue)
26345 {setverdict(pass);} else {setverdict(fail);}
26350 Overall verdict: pass
26356 .*---------------------------------------------------------------------*
26357 :h3. DECODING ,CER, SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
26358 .*---------------------------------------------------------------------*
26361 <TC - DECODING ,CER, SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
26377 BERPDU ::= SEQUENCE
26379 b [5] BOOLEAN OPTIONAL,
26388 import from TempA all;
26390 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26393 const BERPDU myValue := {b := true,
26399 if (dec_BER_PDU('30808501FF0201050000'O) == myValue)
26403 {setverdict(pass);} else {setverdict(fail);}
26408 Overall verdict: pass
26414 .*---------------------------------------------------------------------*
26415 :h3. DECODING ,DER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
26416 .*---------------------------------------------------------------------*
26419 <TC - DECODING ,DER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
26435 {x INTEGER OPTIONAL,
26440 BERPDU ::= SEQUENCE
26442 b BOOLEAN OPTIONAL,
26443 c INTEGER OPTIONAL,
26444 COMPONENTS OF MySeq
26452 import from TempA all;
26454 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26457 const BERPDU myValue := {b := true,
26466 if (dec_BER_PDU('300C8001FF8101058201068301FF'O) == myValue)
26470 {setverdict(pass);} else {setverdict(fail);}
26475 Overall verdict: pass
26481 .*---------------------------------------------------------------------*
26482 :h3. DECODING ,CER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
26483 .*---------------------------------------------------------------------*
26486 <TC - DECODING ,CER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
26503 {x INTEGER OPTIONAL,
26508 BERPDU ::= SEQUENCE
26510 b BOOLEAN OPTIONAL,
26511 c INTEGER OPTIONAL,
26512 COMPONENTS OF MySeq
26520 import from TempA all;
26522 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26524 const BERPDU myValue := {b := true,
26534 if (dec_BER_PDU('30808001FF8101058201068301FF0000'O) == myValue)
26538 {setverdict(pass);} else {setverdict(fail);}
26543 Overall verdict: pass
26549 .*---------------------------------------------------------------------*
26550 :h3. DECODING ,DER, SEQUENCE ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
26551 .*---------------------------------------------------------------------*
26554 <TC - DECODING ,DER, SEQUENCE ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
26570 {x [0] INTEGER OPTIONAL,
26575 BERPDU ::= SEQUENCE
26577 b BOOLEAN OPTIONAL,
26578 c INTEGER OPTIONAL,
26579 COMPONENTS OF MySeq
26588 import from TempA all;
26590 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26593 const BERPDU myValue := {b := true,
26602 if (dec_BER_PDU('300C8001FF8101058201068301FF'O) == myValue)
26606 {setverdict(pass);} else {setverdict(fail);}
26611 Overall verdict: pass
26617 .*---------------------------------------------------------------------*
26618 :h3. DECODING ,CER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
26619 .*---------------------------------------------------------------------*
26622 <TC - DECODING ,CER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
26639 {x [0] INTEGER OPTIONAL,
26644 BERPDU ::= SEQUENCE
26646 b BOOLEAN OPTIONAL,
26647 c INTEGER OPTIONAL,
26648 COMPONENTS OF MySeq
26658 import from TempA all;
26660 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26663 const BERPDU myValue := {b := true,
26672 if (dec_BER_PDU('30808001FF8101058201068301FF0000'O) == myValue)
26676 {setverdict(pass);} else {setverdict(fail);}
26681 Overall verdict: pass
26687 .*---------------------------------------------------------------------*
26688 :h3. DECODING ,DER, SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
26689 .*---------------------------------------------------------------------*
26692 <TC - DECODING ,DER, SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
26709 {x INTEGER OPTIONAL,
26714 BERPDU ::= SEQUENCE
26716 b [0] BOOLEAN OPTIONAL,
26717 c BIT STRING OPTIONAL,
26718 COMPONENTS OF MySeq
26725 import from TempA all;
26727 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26731 const BERPDU myValue := {b := true,
26739 if (dec_BER_PDU('300D8001FF030207800201060401FF'O) == myValue)
26743 {setverdict(pass);} else {setverdict(fail);}
26748 Overall verdict: pass
26754 .*---------------------------------------------------------------------*
26755 :h3. DECODING ,CER, SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
26756 .*---------------------------------------------------------------------*
26759 <TC - DECODING ,CER, SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
26776 {x INTEGER OPTIONAL,
26781 BERPDU ::= SEQUENCE
26783 b [0] BOOLEAN OPTIONAL,
26784 c BIT STRING OPTIONAL,
26785 COMPONENTS OF MySeq
26795 import from TempA all;
26797 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26800 const BERPDU myValue := {b := true,
26808 if (dec_BER_PDU('30808001FF030207800201060401FF0000'O) == myValue)
26812 {setverdict(pass);} else {setverdict(fail);}
26817 Overall verdict: pass
26823 .*---------------------------------------------------------------------*
26824 :h3. DECODING ,DER, SEQUENCE , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
26825 .*---------------------------------------------------------------------*
26828 <TC - DECODING ,DER, SEQUENCE , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
26845 {x [1] INTEGER OPTIONAL,
26850 BERPDU ::= SEQUENCE
26852 b [0] BOOLEAN OPTIONAL,
26853 c BIT STRING OPTIONAL,
26854 COMPONENTS OF MySeq
26861 import from TempA all;
26863 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26867 const BERPDU myValue := {b := true,
26876 if (dec_BER_PDU('300D8001FF030207808101060401FF'O) == myValue)
26880 {setverdict(pass);} else {setverdict(fail);}
26885 Overall verdict: pass
26891 .*---------------------------------------------------------------------*
26892 :h3. DECODING ,CER, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
26893 .*---------------------------------------------------------------------*
26896 <TC - DECODING ,CER, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
26913 {x [1] INTEGER OPTIONAL,
26918 BERPDU ::= SEQUENCE
26920 b [0] BOOLEAN OPTIONAL,
26921 c BIT STRING OPTIONAL,
26922 COMPONENTS OF MySeq
26932 import from TempA all;
26934 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26937 const BERPDU myValue := {b := true,
26946 if (dec_BER_PDU('30808001FF030207808101060401FF0000'O) == myValue)
26950 {setverdict(pass);} else {setverdict(fail);}
26955 Overall verdict: pass
26961 .*---------------------------------------------------------------------*
26962 :h3. DECODING ,DER, SEQUENCE with CHOICE element, AUTOMATIC TAGS
26963 .*---------------------------------------------------------------------*
26966 <TC - DECODING ,DER, SEQUENCE with CHOICE element, AUTOMATIC TAGS>
26982 BERPDU ::= SEQUENCE
27001 import from TempA all;
27003 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27006 const BERPDU myValue := {b := {x := true},
27014 if (dec_BER_PDU('3008A0038001FF810104'O) == myValue)
27018 {setverdict(pass);} else {setverdict(fail);}
27023 Overall verdict: pass
27029 .*---------------------------------------------------------------------*
27030 :h3. DECODING ,CER, SEQUENCE with CHOICE element, AUTOMATIC TAGS
27031 .*---------------------------------------------------------------------*
27034 <TC - DECODING ,CER, SEQUENCE with CHOICE element, AUTOMATIC TAGS>
27049 BERPDU ::= SEQUENCE
27067 import from TempA all;
27069 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27072 const BERPDU myValue := {b := {x := true},
27079 if (dec_BER_PDU('3080A0808001FF00008101040000'O) == myValue)
27083 {setverdict(pass);} else {setverdict(fail);}
27088 Overall verdict: pass
27094 .*---------------------------------------------------------------------*
27095 :h3. DECODING ,DER, SEQUENCE with CHOICE element,
27096 .*---------------------------------------------------------------------*
27099 <TC - DECODING ,DER, SEQUENCE with CHOICE element, >
27114 BERPDU ::= SEQUENCE
27132 import from TempA all;
27134 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27136 const BERPDU myValue := {b := {x := true},
27144 if (dec_BER_PDU('30060101FF020104'O) == myValue)
27148 {setverdict(pass);} else {setverdict(fail);}
27153 Overall verdict: pass
27159 .*---------------------------------------------------------------------*
27160 :h3. DECODING ,CER, SEQUENCE with CHOICE element,
27161 .*---------------------------------------------------------------------*
27164 <TC - DECODING ,CER, SEQUENCE with CHOICE element, >
27179 BERPDU ::= SEQUENCE
27196 import from TempA all;
27198 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27201 const BERPDU myValue := {b := {x := true},
27208 if (dec_BER_PDU('30800101FF0201040000'O) == myValue)
27212 {setverdict(pass);} else {setverdict(fail);}
27217 Overall verdict: pass
27223 .*---------------------------------------------------------------------*
27224 :h3. DECODING ,DER,SEQUENCE with EXTENSION , AUTOMATIC TAGS
27225 .*---------------------------------------------------------------------*
27228 <TC - DECODING ,DER,SEQUENCE with EXTENSION , AUTOMATIC TAGS>
27244 BERPDU ::= SEQUENCE
27264 import from TempA all;
27266 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27269 const BERPDU myValue := {
27278 if (dec_BER_PDU('300D8001FF8101FF83020780820104'O) == myValue)
27282 {setverdict(pass);} else {setverdict(fail);}
27287 Overall verdict: pass
27293 .*---------------------------------------------------------------------*
27294 :h3. DECODING ,CER, SEQUENCE with EXTENSION , AUTOMATIC TAGS
27295 .*---------------------------------------------------------------------*
27298 <TC - DECODING ,CER, SEQUENCE with EXTENSION , AUTOMATIC TAGS>
27314 BERPDU ::= SEQUENCE
27334 import from TempA all;
27336 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27339 const BERPDU myValue := {
27348 if (dec_BER_PDU('30808001FF8101FF830207808201040000'O) == myValue)
27352 {setverdict(pass);} else {setverdict(fail);}
27357 Overall verdict: pass
27363 .*---------------------------------------------------------------------*
27364 :h3. DECODING SEQUENCE with Long Form , AUTOMATIC TAGS
27365 .*---------------------------------------------------------------------*
27368 <TC - DECODING SEQUENCE with Long Form , AUTOMATIC TAGS>
27384 BERPDU ::= SEQUENCE
27404 import from TempA all;
27406 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27409 const BERPDU myValue := {
27418 if (dec_BER_PDU('308300000D8001FF8101FF83020780820104'O) == myValue)
27422 {setverdict(pass);} else {setverdict(fail);}
27427 Overall verdict: pass
27433 .*---------------------------------------------------------------------*
27434 :h3. DECODING , DER, SEQUENCE with fields of different types ,
27435 .*---------------------------------------------------------------------*
27438 <TC - DECODING , DER, SEQUENCE with fields of different types ,>
27452 BERPDU ::= SEQUENCE
27457 d ENUMERATED {first ,second ,third},
27462 h OBJECT IDENTIFIER,
27464 j CHOICE {x1 [1] BOOLEAN,
27465 y1 [2] OCTET STRING},
27467 k SEQUENCE{x2 NULL,
27470 l SET { x3 BIT STRING,
27473 m [3] SEQUENCE OF INTEGER,
27474 n [4] SET OF BOOLEAN
27478 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
27485 import from TempA all;
27487 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27490 const BERPDU myValue := {a := NULL,
27499 j := {x1 := true } ,
27518 if (dec_BER_PDU('304505000101FF0201020A0100030207800402FFFF06030002031603414243A1030101FF300505000101FF3106030207800500A3083006020101020102A40831060101FF0101FF'O) == myValue)
27522 {setverdict(pass);} else {setverdict(fail);}
27527 Overall verdict: pass
27533 .*---------------------------------------------------------------------*
27534 :h3. DECODING , DER, SEQUENCE with fields of different types ,
27535 .*---------------------------------------------------------------------*
27538 <TC - DECODING , DER, SEQUENCE with fields of different types ,>
27552 BERPDU ::= SEQUENCE
27557 d ENUMERATED {first ,second ,third},
27562 h OBJECT IDENTIFIER,
27564 j CHOICE {x1 [1] BOOLEAN,
27565 y1 [2] OCTET STRING},
27567 k SEQUENCE{x2 NULL,
27570 l SET { x3 BIT STRING,
27573 m [3] SEQUENCE OF INTEGER,
27574 n [4] SET OF BOOLEAN
27578 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
27585 import from TempA all;
27587 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27590 const BERPDU myValue := {a := NULL,
27594 // e := 1.0, 090603312E452B30
27599 j := {x1 := true } ,
27618 if (dec_BER_PDU('308005000101FF0201020A0100030207800402FFFF06030002031603414243A1800101FF0000308005000101FF000031800302078005000000A380308002010102010200000000A48031800101FF0101FF000000000000'O) == myValue)
27622 {setverdict(pass);} else {setverdict(fail);}
27627 Overall verdict: pass
27633 .*---------------------------------------------------------------------*
27634 :h3. DECODING , DER, SEQUENCE with fields of different types , AUTOMATIC TAGS
27635 .*---------------------------------------------------------------------*
27638 <TC - DECODING , DER, SEQUENCE with fields of different types , AUTOMATIC TAGS>
27653 BERPDU ::= SEQUENCE
27658 d ENUMERATED {first ,second ,third},
27663 h OBJECT IDENTIFIER,
27665 j CHOICE {x1 BOOLEAN,
27668 k SEQUENCE{x2 NULL,
27671 l SET { x3 BIT STRING,
27674 m SEQUENCE OF INTEGER,
27677 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
27684 import from TempA all;
27686 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27689 const BERPDU myValue := {a := NULL,
27698 j := {x1 := true } ,
27718 if (dec_BER_PDU('304380008101FF8201028301008400850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB06800207808100AC06020101020102AD060101FF0101FF'O) == myValue)
27722 {setverdict(pass);} else {setverdict(fail);}
27727 Overall verdict: pass
27733 .*---------------------------------------------------------------------*
27734 :h3. DECODING , DER, SEQUENCE with fields of different types ,AUTOMATIC TAGS
27735 .*---------------------------------------------------------------------*
27738 <TC - DECODING , DER, SEQUENCE with fields of different types ,AUTOMATIC TAGS>
27752 BERPDU ::= SEQUENCE
27757 d ENUMERATED {first ,second ,third},
27762 h OBJECT IDENTIFIER,
27764 j CHOICE {x1 BOOLEAN,
27767 k SEQUENCE{x2 NULL,
27770 l SET { x3 BIT STRING,
27773 m SEQUENCE OF INTEGER,
27776 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
27784 import from TempA all;
27786 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27789 const BERPDU myValue := {a := NULL,
27798 j := {x1 := true } ,
27818 if (dec_BER_PDU('308080008101FF8201028301008400850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB808002078081000000AC800201010201020000AD800101FF0101FF00000000'O) == myValue)
27822 {setverdict(pass);} else {setverdict(fail);}
27827 Overall verdict: pass
27833 .*---------------------------------------------------------------------*
27834 :h3.CER + DER encoding of SEQUENCE OF INTEGER (empty)
27835 .*---------------------------------------------------------------------*
27838 <TC - CER + DER encoding of SEQUENCE OF INTEGER (empty)>
27847 BERPDU ::= SEQUENCE OF INTEGER
27855 import from TempA all;
27856 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
27857 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
27859 const BERPDU myValue := { }
27866 if ((enc_DER_PDU(myValue) == '3000'O)and(enc_CER_PDU(myValue) == '30800000'O)) {setverdict(pass);} else {setverdict(fail);}
27870 Overall verdict: pass
27876 .*---------------------------------------------------------------------*
27877 :h3.CER + DER encoding of SEQUENCE OF BOOLEAN
27878 .*---------------------------------------------------------------------*
27881 <TC - CER + DER encoding of SEQUENCE OF BOOLEAN>
27890 BERPDU ::= SEQUENCE OF BOOLEAN
27898 import from TempA all;
27899 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
27900 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
27902 const BERPDU myValue := {true, false }
27909 if ((enc_DER_PDU(myValue) == '30060101FF010100'O)and(enc_CER_PDU(myValue) == '30800101FF0101000000'O)) {setverdict(pass);} else {setverdict(fail);}
27913 Overall verdict: pass
27919 .*---------------------------------------------------------------------*
27920 :h3.CER + DER encoding of SEQUENCE OF OCTET STRING
27921 .*---------------------------------------------------------------------*
27924 <TC - CER + DER encoding of SEQUENCE OF OCTET STRING >
27933 BERPDU ::= SEQUENCE OF OCTET STRING
27939 import from TempA all;
27940 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
27941 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
27943 const BERPDU myValue := {'FFFF'O, 'AB'O };
27947 if ((enc_DER_PDU(myValue) == '30070402FFFF0401AB'O)and(enc_CER_PDU(myValue) == '30800402FFFF0401AB0000'O)) {setverdict(pass);} else {setverdict(fail);}
27951 Overall verdict: pass
27957 .*---------------------------------------------------------------------*
27958 :h3.CER + DER encoding of SEQUENCE OF SEQUENCE
27959 .*---------------------------------------------------------------------*
27962 <TC - CER + DER encoding of SEQUENCE OF SEQUENCE >
27971 BERPDU ::= SEQUENCE OF SEQUENCE {a INTEGER, b BOOLEAN}
27977 import from TempA all;
27978 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
27979 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
27981 const BERPDU myValue := {
27996 if ((enc_DER_PDU(myValue) == '301030060201050101FF3006020103010100'O)and(enc_CER_PDU(myValue) == '308030800201050101FF0000308002010301010000000000'O)) {setverdict(pass);} else {setverdict(fail);}
28000 Overall verdict: pass
28006 .*---------------------------------------------------------------------*
28007 :h3.CER + DER encoding of SEQUENCE OF SET
28008 .*---------------------------------------------------------------------*
28011 <TC - CER + DER encoding of SEQUENCE OF SET >
28020 BERPDU ::= SEQUENCE OF SET {a INTEGER, b BOOLEAN}
28026 import from TempA all;
28027 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
28028 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
28030 const BERPDU myValue := {
28045 if ((enc_DER_PDU(myValue) == '301031060101FF0201053106010100020103'O)and(enc_CER_PDU(myValue) == '308031800101FF0201050000318001010002010300000000'O)) {setverdict(pass);} else {setverdict(fail);}
28049 Overall verdict: pass
28055 .*---------------------------------------------------------------------*
28056 :h3.CER + DER encoding of SEQUENCE OF CHOICE
28057 .*---------------------------------------------------------------------*
28060 <TC - CER + DER encoding of SEQUENCE OF CHOICE >
28069 BERPDU ::= SEQUENCE OF CHOICE{a INTEGER, b BOOLEAN}
28075 import from TempA all;
28076 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
28077 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
28079 const BERPDU myValue := {
28092 if ((enc_DER_PDU(myValue) == '3006020105010100'O)and(enc_CER_PDU(myValue) == '30800201050101000000'O)) {setverdict(pass);} else {setverdict(fail);}
28096 Overall verdict: pass
28102 .*---------------------------------------------------------------------*
28103 :h3.CER + DER encoding of SEQUENCE OF SEQUENCE OF
28104 .*---------------------------------------------------------------------*
28107 <TC - CER + DER encoding of SEQUENCE OF SEQUENCE OF>
28116 BERPDU ::= SEQUENCE OF SEQUENCE OF INTEGER
28122 import from TempA all;
28123 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
28124 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
28126 const BERPDU myValue := {
28142 if ((enc_DER_PDU(myValue) == '301630090201050201060201073009020101020102020103'O)and(enc_CER_PDU(myValue) == '308030800201050201060201070000308002010102010202010300000000'O)) {setverdict(pass);} else {setverdict(fail);}
28146 Overall verdict: pass
28152 .*---------------------------------------------------------------------*
28153 :h3.CER + DER encoding of SEQUENCE OF SET OF
28154 .*---------------------------------------------------------------------*
28157 <TC - CER + DER encoding of SEQUENCE OF SET OF>
28166 BERPDU ::= SEQUENCE OF SET OF INTEGER
28172 import from TempA all;
28173 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
28174 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
28176 const BERPDU myValue := {
28192 if ((enc_DER_PDU(myValue) == '301631090201050201060201073109020101020102020103'O)and(enc_CER_PDU(myValue) == '308031800201050201060201070000318002010102010202010300000000'O)) {setverdict(pass);} else {setverdict(fail);}
28196 Overall verdict: pass
28202 .*---------------------------------------------------------------------*
28203 :h3.CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN
28204 .*---------------------------------------------------------------------*
28207 <TC - CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN>
28216 BERPDU ::= [0] SEQUENCE OF BOOLEAN
28224 import from TempA all;
28225 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
28226 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
28228 const BERPDU myValue := {true, false }
28235 if ((enc_DER_PDU(myValue) == 'A00830060101FF010100'O)and(enc_CER_PDU(myValue) == 'A08030800101FF01010000000000'O)) {setverdict(pass);} else {setverdict(fail);}
28239 Overall verdict: pass
28245 .*---------------------------------------------------------------------*
28246 :h3.CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING
28247 .*---------------------------------------------------------------------*
28250 <TC - CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING>
28264 BERPDU ::= [0] SEQUENCE OF BOOLEAN
28272 import from TempA all;
28273 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
28274 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
28276 const BERPDU myValue := {true, false }
28283 if ((enc_DER_PDU(myValue) == 'A00830060101FF010100'O)and(enc_CER_PDU(myValue) == 'A08030800101FF01010000000000'O)) {setverdict(pass);} else {setverdict(fail);}
28287 Overall verdict: pass
28293 .*---------------------------------------------------------------------*
28294 :h3.CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING
28295 .*---------------------------------------------------------------------*
28298 <TC - CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING>
28312 BERPDU ::= [0] SEQUENCE OF BOOLEAN
28320 import from TempA all;
28321 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
28322 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
28324 const BERPDU myValue := {true, false }
28331 if ((enc_DER_PDU(myValue) == 'A0060101FF010100'O)and(enc_CER_PDU(myValue) == 'A0800101FF0101000000'O)) {setverdict(pass);} else {setverdict(fail);}
28335 Overall verdict: pass
28341 .*---------------------------------------------------------------------*
28342 :h3. DECODING DER, SEQUENCE OF INTEGER (empty)
28343 .*---------------------------------------------------------------------*
28346 <TC - DECODING DER, SEQUENCE OF INTEGER (empty)>
28355 BERPDU ::= SEQUENCE OF INTEGER
28361 import from TempA all;
28363 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28365 const BERPDU myValue := { }
28370 if (dec_BER_PDU('3000'O) == myValue)
28372 {setverdict(pass);} else {setverdict(fail);}
28377 Overall verdict: pass
28383 .*---------------------------------------------------------------------*
28384 :h3. DECODING CER, SEQUENCE OF INTEGER (empty)
28385 .*---------------------------------------------------------------------*
28388 <TC - DECODING CER, SEQUENCE OF INTEGER (empty)>
28397 BERPDU ::= SEQUENCE OF INTEGER
28403 import from TempA all;
28405 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28407 const BERPDU myValue := { }
28412 if (dec_BER_PDU('30800000'O) == myValue)
28414 {setverdict(pass);} else {setverdict(fail);}
28419 Overall verdict: pass
28425 .*---------------------------------------------------------------------*
28426 :h3. DECODING DER, SEQUENCE OF BOOLEAN
28427 .*---------------------------------------------------------------------*
28430 <TC - DECODING DER, SEQUENCE OF BOOLEAN>
28439 BERPDU ::= SEQUENCE OF BOOLEAN
28445 import from TempA all;
28447 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28449 const BERPDU myValue := {true, false }
28454 if (dec_BER_PDU('30060101FF010100'O) == myValue)
28456 {setverdict(pass);} else {setverdict(fail);}
28461 Overall verdict: pass
28467 .*---------------------------------------------------------------------*
28468 :h3. DECODING CER, SEQUENCE OF BOOLEAN
28469 .*---------------------------------------------------------------------*
28472 <TC - DECODING CER, SEQUENCE OF BOOLEAN>
28481 BERPDU ::= SEQUENCE OF BOOLEAN
28487 import from TempA all;
28489 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28491 const BERPDU myValue := {true, false }
28496 if (dec_BER_PDU('30800101FF0101000000'O) == myValue)
28498 {setverdict(pass);} else {setverdict(fail);}
28503 Overall verdict: pass
28509 .*---------------------------------------------------------------------*
28510 :h3. DECODING DER,SEQUENCE OF OCTET STRING
28511 .*---------------------------------------------------------------------*
28514 <TC - DECODING DER,SEQUENCE OF OCTET STRING >
28523 BERPDU ::= SEQUENCE OF OCTET STRING
28529 import from TempA all;
28531 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28533 const BERPDU myValue := {'FFFF'O, 'AB'O };
28538 if (dec_BER_PDU('30070402FFFF0401AB'O) == myValue)
28540 {setverdict(pass);} else {setverdict(fail);}
28545 Overall verdict: pass
28551 .*---------------------------------------------------------------------*
28552 :h3. DECODING CER,SEQUENCE OF OCTET STRING
28553 .*---------------------------------------------------------------------*
28556 <TC - DECODING CER,SEQUENCE OF OCTET STRING >
28565 BERPDU ::= SEQUENCE OF OCTET STRING
28571 import from TempA all;
28573 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28575 const BERPDU myValue := {'FFFF'O, 'AB'O };
28580 if (dec_BER_PDU('30800402FFFF0401AB0000'O) == myValue)
28582 {setverdict(pass);} else {setverdict(fail);}
28587 Overall verdict: pass
28593 .*---------------------------------------------------------------------*
28594 :h3. DECODING DER,SEQUENCE OF SEQUENCE
28595 .*---------------------------------------------------------------------*
28598 <TC - DECODING DER,SEQUENCE OF SEQUENCE >
28607 BERPDU ::= SEQUENCE OF SEQUENCE {a INTEGER, b BOOLEAN}
28613 import from TempA all;
28615 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28617 const BERPDU myValue := {
28633 if (dec_BER_PDU('301030060201050101FF3006020103010100'O) == myValue)
28635 {setverdict(pass);} else {setverdict(fail);}
28640 Overall verdict: pass
28646 .*---------------------------------------------------------------------*
28647 :h3. DECODING CER,SEQUENCE OF SEQUENCE
28648 .*---------------------------------------------------------------------*
28651 <TC - DECODING CER,SEQUENCE OF SEQUENCE >
28660 BERPDU ::= SEQUENCE OF SEQUENCE {a INTEGER, b BOOLEAN}
28666 import from TempA all;
28668 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28670 const BERPDU myValue := {
28686 if (dec_BER_PDU('308030800201050101FF0000308002010301010000000000'O) == myValue)
28688 {setverdict(pass);} else {setverdict(fail);}
28693 Overall verdict: pass
28699 .*---------------------------------------------------------------------*
28700 :h3. DECODING DER,SEQUENCE OF SET
28701 .*---------------------------------------------------------------------*
28704 <TC - DECODING DER,SEQUENCE OF SET >
28713 BERPDU ::= SEQUENCE OF SET {a INTEGER, b BOOLEAN}
28719 import from TempA all;
28721 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28723 const BERPDU myValue := {
28739 if (dec_BER_PDU('301031060101FF0201053106010100020103'O) == myValue)
28741 {setverdict(pass);} else {setverdict(fail);}
28746 Overall verdict: pass
28752 .*---------------------------------------------------------------------*
28753 :h3. DECODING CER,SEQUENCE OF SET
28754 .*---------------------------------------------------------------------*
28757 <TC - DECODING CER,SEQUENCE OF SET >
28766 BERPDU ::= SEQUENCE OF SET {a INTEGER, b BOOLEAN}
28772 import from TempA all;
28774 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28776 const BERPDU myValue := {
28792 if (dec_BER_PDU('308031800101FF0201050000318001010002010300000000'O) == myValue)
28794 {setverdict(pass);} else {setverdict(fail);}
28799 Overall verdict: pass
28805 .*---------------------------------------------------------------------*
28806 :h3. DECODING DER,SEQUENCE OF CHOICE
28807 .*---------------------------------------------------------------------*
28810 <TC - DECODING DER,SEQUENCE OF CHOICE >
28819 BERPDU ::= SEQUENCE OF CHOICE{a INTEGER, b BOOLEAN}
28825 import from TempA all;
28827 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28829 const BERPDU myValue := {
28843 if (dec_BER_PDU('3006020105010100'O) == myValue)
28845 {setverdict(pass);} else {setverdict(fail);}
28850 Overall verdict: pass
28856 .*---------------------------------------------------------------------*
28857 :h3. DECODING CER,SEQUENCE OF CHOICE
28858 .*---------------------------------------------------------------------*
28861 <TC - DECODING CER,SEQUENCE OF CHOICE >
28870 BERPDU ::= SEQUENCE OF CHOICE{a INTEGER, b BOOLEAN}
28876 import from TempA all;
28878 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28880 const BERPDU myValue := {
28894 if (dec_BER_PDU('30800201050101000000'O) == myValue)
28896 {setverdict(pass);} else {setverdict(fail);}
28901 Overall verdict: pass
28907 .*---------------------------------------------------------------------*
28908 :h3. DECODING DER,SEQUENCE OF SEQUENCE OF
28909 .*---------------------------------------------------------------------*
28912 <TC - DECODING DER,SEQUENCE OF SEQUENCE OF>
28921 BERPDU ::= SEQUENCE OF SEQUENCE OF INTEGER
28927 import from TempA all;
28929 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28931 const BERPDU myValue := {
28948 if (dec_BER_PDU('301630090201050201060201073009020101020102020103'O) == myValue)
28950 {setverdict(pass);} else {setverdict(fail);}
28955 Overall verdict: pass
28961 .*---------------------------------------------------------------------*
28962 :h3. DECODING CER,SEQUENCE OF SEQUENCE OF
28963 .*---------------------------------------------------------------------*
28966 <TC - DECODING CER,SEQUENCE OF SEQUENCE OF>
28975 BERPDU ::= SEQUENCE OF SEQUENCE OF INTEGER
28981 import from TempA all;
28983 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28985 const BERPDU myValue := {
29002 if (dec_BER_PDU('308030800201050201060201070000308002010102010202010300000000'O) == myValue)
29004 {setverdict(pass);} else {setverdict(fail);}
29009 Overall verdict: pass
29015 .*---------------------------------------------------------------------*
29016 :h3. DECODING DER,SEQUENCE OF SET OF
29017 .*---------------------------------------------------------------------*
29020 <TC - DECODING DER,SEQUENCE OF SET OF>
29029 BERPDU ::= SEQUENCE OF SET OF INTEGER
29035 import from TempA all;
29037 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29039 const BERPDU myValue := {
29056 if (dec_BER_PDU('301631090201050201060201073109020101020102020103'O) == myValue)
29058 {setverdict(pass);} else {setverdict(fail);}
29063 Overall verdict: pass
29069 .*---------------------------------------------------------------------*
29070 :h3. DECODING CER,SEQUENCE OF SET OF
29071 .*---------------------------------------------------------------------*
29074 <TC - DECODING CER,SEQUENCE OF SET OF>
29083 BERPDU ::= SEQUENCE OF SET OF INTEGER
29089 import from TempA all;
29091 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29093 const BERPDU myValue := {
29110 if (dec_BER_PDU('308031800201050201060201070000318002010102010202010300000000'O) == myValue)
29112 {setverdict(pass);} else {setverdict(fail);}
29117 Overall verdict: pass
29123 .*---------------------------------------------------------------------*
29124 :h3. DECODING DER,TAGGED SEQUENCE OF BOOLEAN
29125 .*---------------------------------------------------------------------*
29128 <TC - DECODING DER,TAGGED SEQUENCE OF BOOLEAN>
29137 BERPDU ::= [0] SEQUENCE OF BOOLEAN
29143 import from TempA all;
29145 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29147 const BERPDU myValue := {true, false }
29152 if (dec_BER_PDU('A00830060101FF010100'O) == myValue)
29154 {setverdict(pass);} else {setverdict(fail);}
29159 Overall verdict: pass
29165 .*---------------------------------------------------------------------*
29166 :h3. DECODING CER,TAGGED SEQUENCE OF BOOLEAN
29167 .*---------------------------------------------------------------------*
29170 <TC - DECODING CER,TAGGED SEQUENCE OF BOOLEAN>
29179 BERPDU ::= [0] SEQUENCE OF BOOLEAN
29185 import from TempA all;
29187 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29189 const BERPDU myValue := {true, false }
29194 if (dec_BER_PDU('A08030800101FF01010000000000'O) == myValue)
29196 {setverdict(pass);} else {setverdict(fail);}
29201 Overall verdict: pass
29207 .*---------------------------------------------------------------------*
29208 :h3. DECODING DER,TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING
29209 .*---------------------------------------------------------------------*
29212 <TC - DECODING DER,TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING>
29225 BERPDU ::= [0] SEQUENCE OF BOOLEAN
29231 import from TempA all;
29233 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29235 const BERPDU myValue := {true, false }
29240 if (dec_BER_PDU('A00830060101FF010100'O) == myValue)
29242 {setverdict(pass);} else {setverdict(fail);}
29247 Overall verdict: pass
29253 .*---------------------------------------------------------------------*
29254 :h3. DECODING CER,TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING
29255 .*---------------------------------------------------------------------*
29258 <TC - DECODING CER,TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING>
29271 BERPDU ::= [0] SEQUENCE OF BOOLEAN
29277 import from TempA all;
29279 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29281 const BERPDU myValue := {true, false }
29286 if (dec_BER_PDU('A08030800101FF01010000000000'O) == myValue)
29288 {setverdict(pass);} else {setverdict(fail);}
29293 Overall verdict: pass
29299 .*---------------------------------------------------------------------*
29300 :h3. DECODING DER,TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING
29301 .*---------------------------------------------------------------------*
29304 <TC - DECODING DER,TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING>
29317 BERPDU ::= [0] SEQUENCE OF BOOLEAN
29323 import from TempA all;
29325 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29327 const BERPDU myValue := {true, false }
29332 if (dec_BER_PDU('A0060101FF010100'O) == myValue)
29334 {setverdict(pass);} else {setverdict(fail);}
29339 Overall verdict: pass
29345 .*---------------------------------------------------------------------*
29346 :h3. DECODING CER,TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING
29347 .*---------------------------------------------------------------------*
29350 <TC - DECODING CER,TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING>
29363 BERPDU ::= [0] SEQUENCE OF BOOLEAN
29369 import from TempA all;
29371 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29373 const BERPDU myValue := {true, false }
29378 if (dec_BER_PDU('A0800101FF0101000000'O) == myValue)
29380 {setverdict(pass);} else {setverdict(fail);}
29385 Overall verdict: pass
29391 .*---------------------------------------------------------------------*
29392 :h3.CER + DER encoding of SET (EMPTY)
29393 .*---------------------------------------------------------------------*
29396 <TC - CER + DER encoding of SET (EMPTY)>
29407 b BOOLEAN OPTIONAL,
29416 import from TempA all;
29417 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29418 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29420 const BERPDU myValue := {b := omit,
29428 if ((enc_DER_PDU(myValue) == '3100'O)and(enc_CER_PDU(myValue) == '31800000'O)) {setverdict(pass);} else {setverdict(fail);}
29432 Overall verdict: pass
29438 .*---------------------------------------------------------------------*
29439 :h3.CER + DER encoding of SET (only one element is used)
29440 .*---------------------------------------------------------------------*
29443 <TC - CER + DER encoding of SET (only one element is used)>
29454 b BOOLEAN OPTIONAL,
29463 import from TempA all;
29464 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29465 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29467 const BERPDU myValue := {b := true,
29475 if ((enc_DER_PDU(myValue) == '31030101FF'O)and(enc_CER_PDU(myValue) == '31800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
29479 Overall verdict: pass
29485 .*---------------------------------------------------------------------*
29486 :h3.CER + DER encoding of SET (both elements are used)
29487 .*---------------------------------------------------------------------*
29490 <TC - CER + DER encoding of SET (both elements are used)>
29501 b BOOLEAN OPTIONAL,
29510 import from TempA all;
29511 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29512 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29514 const BERPDU myValue := {b := true,
29522 if ((enc_DER_PDU(myValue) == '31060101FF020105'O)and(enc_CER_PDU(myValue) == '31800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29526 Overall verdict: pass
29532 .*---------------------------------------------------------------------*
29533 :h3. encoding of SET(different order) (both elements are used)
29534 .*---------------------------------------------------------------------*
29537 <TC - encoding of SET(different order) (both elements are used)>
29548 b BOOLEAN OPTIONAL,
29557 import from TempA all;
29558 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29559 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29561 const BERPDU myValue := { c := 5,
29569 if ((enc_DER_PDU(myValue) == '31060101FF020105'O)and(enc_CER_PDU(myValue) == '31800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29573 Overall verdict: pass
29579 .*---------------------------------------------------------------------*
29580 :h3.CER + DER encoding of SET (different order2)(both elements are used)
29581 .*---------------------------------------------------------------------*
29584 <TC - CER + DER encoding of SET (different order2)(both elements are used)>
29596 c INTEGER OPTIONAL,
29605 import from TempA all;
29606 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29607 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29609 const BERPDU myValue := {b := true,
29617 if ((enc_DER_PDU(myValue) == '31060101FF020105'O)and(enc_CER_PDU(myValue) == '31800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29621 Overall verdict: pass
29627 .*---------------------------------------------------------------------*
29628 :h3.CER + DER encoding of SET (one element is equal to Default)
29629 .*---------------------------------------------------------------------*
29632 <TC - CER + DER encoding of SET (one element is equal to Default)>
29643 b BOOLEAN DEFAULT TRUE,
29652 import from TempA all;
29653 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29654 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29656 const BERPDU myValue := {b := true,
29664 if ((enc_DER_PDU(myValue) == '3103020105'O)and(enc_CER_PDU(myValue) == '31800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29668 Overall verdict: pass
29674 .*---------------------------------------------------------------------*
29675 :h3. encoding of SET (different order)(one element is equal to Default)
29676 .*---------------------------------------------------------------------*
29679 <TC - encoding of SET (different order)(one element is equal to Default)>
29690 b BOOLEAN DEFAULT TRUE,
29699 import from TempA all;
29700 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29701 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29703 const BERPDU myValue := {
29712 if ((enc_DER_PDU(myValue) == '3103020105'O)and(enc_CER_PDU(myValue) == '31800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29716 Overall verdict: pass
29722 .*---------------------------------------------------------------------*
29723 :h3.CER + DER encoding of SET (one element is not equal to Default)
29724 .*---------------------------------------------------------------------*
29727 <TC - CER + DER encoding of SET (one element is not equal to Default)>
29738 b BOOLEAN DEFAULT TRUE,
29747 import from TempA all;
29748 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29749 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29751 const BERPDU myValue := {b := false,
29759 if ((enc_DER_PDU(myValue) == '3106010100020105'O)and(enc_CER_PDU(myValue) == '31800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29763 Overall verdict: pass
29769 .*---------------------------------------------------------------------*
29770 :h3. encoding of SET (different order) (one element is not equal to Default)
29771 .*---------------------------------------------------------------------*
29774 <TC - encoding of SET (different order) (one element is not equal to Default)>
29785 b BOOLEAN DEFAULT TRUE,
29794 import from TempA all;
29795 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29796 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29798 const BERPDU myValue := {
29807 if ((enc_DER_PDU(myValue) == '3106010100020105'O)and(enc_CER_PDU(myValue) == '31800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29811 Overall verdict: pass
29817 .*---------------------------------------------------------------------*
29818 :h3. encoding of SET (different order2) (one element is not equal to Default)
29819 .*---------------------------------------------------------------------*
29822 <TC - encoding of SET (different order2) (one element is not equal to Default)>
29834 c INTEGER OPTIONAL,
29835 b BOOLEAN DEFAULT TRUE
29843 import from TempA all;
29844 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29845 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29847 const BERPDU myValue := {
29856 if ((enc_DER_PDU(myValue) == '3106010100020105'O)and(enc_CER_PDU(myValue) == '31800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29860 Overall verdict: pass
29866 .*---------------------------------------------------------------------*
29867 :h3.CER + DER encoding of SET (EMPTY), AUTOMATIC TAGGING
29868 .*---------------------------------------------------------------------*
29871 <TC - CER + DER encoding of SET (EMPTY), AUTOMATIC TAGGING>
29887 b BOOLEAN OPTIONAL,
29896 import from TempA all;
29897 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29898 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29900 const BERPDU myValue := {b := omit,
29908 if ((enc_DER_PDU(myValue) == '3100'O)and(enc_CER_PDU(myValue) == '31800000'O)) {setverdict(pass);} else {setverdict(fail);}
29912 Overall verdict: pass
29918 .*---------------------------------------------------------------------*
29919 :h3.CER + DER encoding of SET(only one element is used) AUTOMATIC TAGGING
29920 .*---------------------------------------------------------------------*
29923 <TC - CER + DER encoding of SET(only one element is used) AUTOMATIC TAGGING>
29939 b BOOLEAN OPTIONAL,
29948 import from TempA all;
29949 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29950 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29952 const BERPDU myValue := {b := true,
29960 if ((enc_DER_PDU(myValue) == '31038001FF'O)and(enc_CER_PDU(myValue) == '31808001FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
29964 Overall verdict: pass
29970 .*---------------------------------------------------------------------*
29971 :h3. encoding of SET (different order)(only one element is used) AUTOMATIC TAGGING
29972 .*---------------------------------------------------------------------*
29975 <TC - encoding of SET (different order)(only one element is used) AUTOMATIC TAGGING>
29991 b BOOLEAN OPTIONAL,
30000 import from TempA all;
30001 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30002 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30004 const BERPDU myValue := {
30013 if ((enc_DER_PDU(myValue) == '31038001FF'O)and(enc_CER_PDU(myValue) == '31808001FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
30017 Overall verdict: pass
30023 .*---------------------------------------------------------------------*
30024 :h3.CER + DER encoding of SET (both elements are used) AUTOMATIC TAGGING
30025 .*---------------------------------------------------------------------*
30028 <TC - CER + DER encoding of SET (both elements are used) AUTOMATIC TAGGING>
30044 b BOOLEAN OPTIONAL,
30053 import from TempA all;
30054 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30055 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30057 const BERPDU myValue := {b := true,
30065 if ((enc_DER_PDU(myValue) == '31068001FF810105'O)and(enc_CER_PDU(myValue) == '31808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
30069 Overall verdict: pass
30075 .*---------------------------------------------------------------------*
30076 :h3.encoding of SET (both elements are used)(different order) AUTOMATIC TAGGING
30077 .*---------------------------------------------------------------------*
30080 <TC - encoding of SET (both elements are used)(different order) AUTOMATIC TAGGING>
30096 b BOOLEAN OPTIONAL,
30105 import from TempA all;
30106 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30107 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30109 const BERPDU myValue := {
30118 if ((enc_DER_PDU(myValue) == '31068001FF810105'O)and(enc_CER_PDU(myValue) == '31808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
30122 Overall verdict: pass
30128 .*---------------------------------------------------------------------*
30129 :h3.CER + DER encoding of SET (both elements are used)(different order2) AUTOMATIC TAGGING
30130 .*---------------------------------------------------------------------*
30133 <TC - CER + DER encoding of SET (both elements are used)(different order2) AUTOMATIC TAGGING>
30150 c INTEGER OPTIONAL,
30159 import from TempA all;
30160 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30161 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30163 const BERPDU myValue := {b := true,
30171 if ((enc_DER_PDU(myValue) == '31068001058101FF'O)and(enc_CER_PDU(myValue) == '31808001058101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
30175 Overall verdict: pass
30181 .*---------------------------------------------------------------------*
30182 :h3.CER + DER encoding of SET (one element is equal to Default) AUTOMATIC TAGGING
30183 .*---------------------------------------------------------------------*
30186 <TC - CER + DER encoding of SET (one element is equal to Default) AUTOMATIC TAGGING>
30202 b BOOLEAN DEFAULT TRUE,
30211 import from TempA all;
30212 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30213 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30215 const BERPDU myValue := {b := true,
30223 if ((enc_DER_PDU(myValue) == '3103810105'O)and(enc_CER_PDU(myValue) == '31808101050000'O)) {setverdict(pass);} else {setverdict(fail);}
30227 Overall verdict: pass
30233 .*---------------------------------------------------------------------*
30234 :h3. encoding of SET (different order) (one element is equal to Default) AUTOMATIC TAGGING
30235 .*---------------------------------------------------------------------*
30238 <TC - encoding of SET (different order) (one element is equal to Default) AUTOMATIC TAGGING>
30254 b BOOLEAN DEFAULT TRUE,
30263 import from TempA all;
30264 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30265 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30267 const BERPDU myValue := {
30276 if ((enc_DER_PDU(myValue) == '3103810105'O)and(enc_CER_PDU(myValue) == '31808101050000'O)) {setverdict(pass);} else {setverdict(fail);}
30280 Overall verdict: pass
30286 .*---------------------------------------------------------------------*
30287 :h3.CER + DER encoding of SET (one element is not equal to Default) AUTOMATIC TAGGING
30288 .*---------------------------------------------------------------------*
30291 <TC - CER + DER encoding of SET (one element is not equal to Default) AUTOMATIC TAGGING>
30307 b BOOLEAN DEFAULT TRUE,
30316 import from TempA all;
30317 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30318 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30320 const BERPDU myValue := {b := false,
30328 if ((enc_DER_PDU(myValue) == '3106800100810105'O)and(enc_CER_PDU(myValue) == '31808001008101050000'O)) {setverdict(pass);} else {setverdict(fail);}
30332 Overall verdict: pass
30338 .*---------------------------------------------------------------------*
30339 :h3. encoding of SET (different order)(one element is not equal to Default) AUTOMATIC TAGGING
30340 .*---------------------------------------------------------------------*
30343 <TC - encoding of SET (different order)(one element is not equal to Default) AUTOMATIC TAGGING>
30359 b BOOLEAN DEFAULT TRUE,
30368 import from TempA all;
30369 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30370 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30372 const BERPDU myValue := {
30381 if ((enc_DER_PDU(myValue) == '3106800100810105'O)and(enc_CER_PDU(myValue) == '31808001008101050000'O)) {setverdict(pass);} else {setverdict(fail);}
30385 Overall verdict: pass
30391 .*---------------------------------------------------------------------*
30392 :h3.CER + DER encoding of SET (different order2)(one element is not equal to Default) AUTOMATIC TAGGING
30393 .*---------------------------------------------------------------------*
30396 <TC - CER + DER encoding of SET (different order2)(one element is not equal to Default) AUTOMATIC TAGGING>
30413 c INTEGER OPTIONAL,
30414 b BOOLEAN DEFAULT TRUE
30422 import from TempA all;
30423 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30424 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30426 const BERPDU myValue := {b := false,
30434 if ((enc_DER_PDU(myValue) == '3106800105810100'O)and(enc_CER_PDU(myValue) == '31808001058101000000'O)) {setverdict(pass);} else {setverdict(fail);}
30438 Overall verdict: pass
30444 .*---------------------------------------------------------------------*
30445 :h3.CER + DER encoding of SET (both elements are used) IMPLICIT TAGS for elements
30446 .*---------------------------------------------------------------------*
30449 <TC - CER + DER encoding of SET (both elements are used) IMPLICIT TAGS for elements>
30460 b [30] IMPLICIT BOOLEAN OPTIONAL,
30461 c [31] IMPLICIT INTEGER OPTIONAL
30469 import from TempA all;
30470 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30471 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30473 const BERPDU myValue := {b := true,
30481 if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
30485 Overall verdict: pass
30491 .*---------------------------------------------------------------------*
30492 :h3. encoding of SET (different order) (both elements are used) IMPLICIT TAGS for elements
30493 .*---------------------------------------------------------------------*
30496 <TC - encoding of SET (different order) (both elements are used) IMPLICIT TAGS for elements>
30507 b [30] IMPLICIT BOOLEAN OPTIONAL,
30508 c [31] IMPLICIT INTEGER OPTIONAL
30516 import from TempA all;
30517 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30518 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30520 const BERPDU myValue := {
30529 if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
30533 Overall verdict: pass
30539 .*---------------------------------------------------------------------*
30540 :h3.CER + DER encoding of SET (different order2) (both elements are used) IMPLICIT TAGS for elements
30541 .*---------------------------------------------------------------------*
30544 <TC - CER + DER encoding of SET (different order2) (both elements are used) IMPLICIT TAGS for elements>
30555 c [31] IMPLICIT INTEGER OPTIONAL,
30556 b [30] IMPLICIT BOOLEAN OPTIONAL
30564 import from TempA all;
30565 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30566 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30568 const BERPDU myValue := {b := true,
30576 if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
30580 Overall verdict: pass
30586 .*---------------------------------------------------------------------*
30587 :h3.CER + DER encoding of SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
30588 .*---------------------------------------------------------------------*
30591 <TC - CER + DER encoding of SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
30607 b [30] IMPLICIT BOOLEAN OPTIONAL,
30608 c [31] IMPLICIT INTEGER OPTIONAL
30616 import from TempA all;
30617 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30618 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30620 const BERPDU myValue := {b := true,
30628 if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
30632 Overall verdict: pass
30638 .*---------------------------------------------------------------------*
30639 :h3.encoding of SET (different order) (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
30640 .*---------------------------------------------------------------------*
30643 <TC - encoding of SET (different order) (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
30659 b [30] IMPLICIT BOOLEAN OPTIONAL,
30660 c [31] IMPLICIT INTEGER OPTIONAL
30668 import from TempA all;
30669 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30670 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30672 const BERPDU myValue := {
30681 if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
30685 Overall verdict: pass
30691 .*---------------------------------------------------------------------*
30692 :h3.CER + DER encoding of SET (different order2)(both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
30693 .*---------------------------------------------------------------------*
30696 <TC - CER + DER encoding of SET (different order2)(both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
30712 c [31] IMPLICIT INTEGER OPTIONAL,
30713 b [30] IMPLICIT BOOLEAN OPTIONAL
30722 import from TempA all;
30723 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30724 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30726 const BERPDU myValue := {b := true,
30734 if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
30738 Overall verdict: pass
30744 .*---------------------------------------------------------------------*
30745 :h3.CER + DER encoding of SET (both elements are used) EXPLICIT TAGS for elements
30746 .*---------------------------------------------------------------------*
30749 <TC - CER + DER encoding of SET (both elements are used) EXPLICIT TAGS for elements>
30760 b [30] EXPLICIT BOOLEAN OPTIONAL,
30761 c [31] EXPLICIT INTEGER OPTIONAL
30769 import from TempA all;
30770 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30771 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30773 const BERPDU myValue := {b := true,
30781 if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
30785 Overall verdict: pass
30791 .*---------------------------------------------------------------------*
30792 :h3. encoding of SET (different order)(both elements are used) EXPLICIT TAGS for elements
30793 .*---------------------------------------------------------------------*
30796 <TC - encoding of SET (different order)(both elements are used) EXPLICIT TAGS for elements>
30807 b [30] EXPLICIT BOOLEAN OPTIONAL,
30808 c [31] EXPLICIT INTEGER OPTIONAL
30816 import from TempA all;
30817 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30818 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30820 const BERPDU myValue := {
30829 if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
30833 Overall verdict: pass
30839 .*---------------------------------------------------------------------*
30840 :h3.CER + DER encoding of SET (different order2) (both elements are used) EXPLICIT TAGS for elements
30841 .*---------------------------------------------------------------------*
30844 <TC - CER + DER encoding of SET (different order2) (both elements are used) EXPLICIT TAGS for elements>
30856 c [31] EXPLICIT INTEGER OPTIONAL,
30857 b [30] EXPLICIT BOOLEAN OPTIONAL
30865 import from TempA all;
30866 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30867 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30869 const BERPDU myValue := {b := true,
30877 if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
30881 Overall verdict: pass
30887 .*---------------------------------------------------------------------*
30888 :h3.CER + DER encoding of SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
30889 .*---------------------------------------------------------------------*
30892 <TC - CER + DER encoding of SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
30908 b [30] EXPLICIT BOOLEAN OPTIONAL,
30909 c [31] EXPLICIT INTEGER OPTIONAL
30917 import from TempA all;
30918 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30919 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30921 const BERPDU myValue := {b := true,
30929 if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
30933 Overall verdict: pass
30939 .*---------------------------------------------------------------------*
30940 :h3. encoding of SET (different order) (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
30941 .*---------------------------------------------------------------------*
30944 <TC - encoding of SET (different order) (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
30960 b [30] EXPLICIT BOOLEAN OPTIONAL,
30961 c [31] EXPLICIT INTEGER OPTIONAL
30969 import from TempA all;
30970 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30971 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30973 const BERPDU myValue := {
30982 if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
30986 Overall verdict: pass
30992 .*---------------------------------------------------------------------*
30993 :h3.CER + DER encoding of SET (different order2)(both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
30994 .*---------------------------------------------------------------------*
30997 <TC - CER + DER encoding of SET (different order2)(both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
31013 c [31] EXPLICIT INTEGER OPTIONAL,
31014 b [30] EXPLICIT BOOLEAN OPTIONAL
31023 import from TempA all;
31024 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31025 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31027 const BERPDU myValue := {b := true,
31035 if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
31039 Overall verdict: pass
31045 .*---------------------------------------------------------------------*
31046 :h3.CER + DER encoding of TAGGED SET (both elements are used)
31047 .*---------------------------------------------------------------------*
31050 <TC - CER + DER encoding of TAGGED SET (both elements are used)>
31061 b BOOLEAN OPTIONAL,
31070 import from TempA all;
31071 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31072 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31074 const BERPDU myValue := {b := true,
31082 if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
31086 Overall verdict: pass
31092 .*---------------------------------------------------------------------*
31093 :h3. encoding of TAGGED SET (different order) (both elements are used)
31094 .*---------------------------------------------------------------------*
31097 <TC - encoding of TAGGED SET (different order) (both elements are used)>
31108 b BOOLEAN OPTIONAL,
31117 import from TempA all;
31118 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31119 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31121 const BERPDU myValue := {
31130 if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
31134 Overall verdict: pass
31140 .*---------------------------------------------------------------------*
31141 :h3.CER + DER encoding of TAGGED SET (different order2) (both elements are used)
31142 .*---------------------------------------------------------------------*
31145 <TC - CER + DER encoding of TAGGED SET (different order2) (both elements are used)>
31157 c INTEGER OPTIONAL,
31166 import from TempA all;
31167 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31168 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31170 const BERPDU myValue := {b := true,
31178 if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
31182 Overall verdict: pass
31188 .*---------------------------------------------------------------------*
31189 :h3.CER + DER encoding of TAGGED SET (both elements are used), AUTOMATIC TAGGING ENVIRONMENT
31190 .*---------------------------------------------------------------------*
31193 <TC - CER + DER encoding of TAGGED SET (both elements are used), AUTOMATIC TAGGING ENVIRONMENT>
31209 b BOOLEAN OPTIONAL,
31218 import from TempA all;
31219 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31220 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31222 const BERPDU myValue := {b := true,
31230 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
31234 Overall verdict: pass
31240 .*---------------------------------------------------------------------*
31241 :h3. encoding of TAGGED SET (different order) (both elements are used), AUTOMATIC TAGGING ENVIRONMENT
31242 .*---------------------------------------------------------------------*
31245 <TC - encoding of TAGGED SET (different order) (both elements are used), AUTOMATIC TAGGING ENVIRONMENT>
31261 b BOOLEAN OPTIONAL,
31270 import from TempA all;
31271 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31272 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31274 const BERPDU myValue := {
31283 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
31287 Overall verdict: pass
31293 .*---------------------------------------------------------------------*
31294 :h3.CER + DER encoding of TAGGED SET (different order2) (both elements are used), AUTOMATIC TAGGING ENVIRONMENT
31295 .*---------------------------------------------------------------------*
31298 <TC - CER + DER encoding of TAGGED SET (different order2) (both elements are used), AUTOMATIC TAGGING ENVIRONMENT>
31314 c INTEGER OPTIONAL,
31323 import from TempA all;
31324 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31325 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31327 const BERPDU myValue := {b := true,
31335 if ((enc_DER_PDU(myValue) == 'A0068001058101FF'O)and(enc_CER_PDU(myValue) == 'A0808001058101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
31339 Overall verdict: pass
31345 .*---------------------------------------------------------------------*
31346 :h3.CER + DER encoding of TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT
31347 .*---------------------------------------------------------------------*
31350 <TC - CER + DER encoding of TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
31366 b BOOLEAN OPTIONAL,
31375 import from TempA all;
31376 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31377 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31379 const BERPDU myValue := {b := true,
31387 if ((enc_DER_PDU(myValue) == 'A0060101FF020105'O)and(enc_CER_PDU(myValue) == 'A0800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
31391 Overall verdict: pass
31397 .*---------------------------------------------------------------------*
31398 :h3. encoding of TAGGED SET (different order)(both elements are used), IMPLICIT TAGGING ENVIRONMENT
31399 .*---------------------------------------------------------------------*
31402 <TC - encoding of TAGGED SET (different order)(both elements are used), IMPLICIT TAGGING ENVIRONMENT>
31418 b BOOLEAN OPTIONAL,
31427 import from TempA all;
31428 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31429 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31431 const BERPDU myValue := {
31440 if ((enc_DER_PDU(myValue) == 'A0060101FF020105'O)and(enc_CER_PDU(myValue) == 'A0800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
31444 Overall verdict: pass
31450 .*---------------------------------------------------------------------*
31451 :h3.CER + DER encoding of TAGGED SET (different order2)(both elements are used), IMPLICIT TAGGING ENVIRONMENT
31452 .*---------------------------------------------------------------------*
31455 <TC - CER + DER encoding of TAGGED SET (different order2)(both elements are used), IMPLICIT TAGGING ENVIRONMENT>
31472 c INTEGER OPTIONAL,
31481 import from TempA all;
31482 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31483 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31485 const BERPDU myValue := {b := true,
31493 if ((enc_DER_PDU(myValue) == 'A0060101FF020105'O)and(enc_CER_PDU(myValue) == 'A0800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
31497 Overall verdict: pass
31503 .*---------------------------------------------------------------------*
31504 :h3.CER + DER encoding of TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT
31505 .*---------------------------------------------------------------------*
31508 <TC - CER + DER encoding of TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
31524 b BOOLEAN OPTIONAL,
31533 import from TempA all;
31534 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31535 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31537 const BERPDU myValue := {b := true,
31545 if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
31549 Overall verdict: pass
31555 .*---------------------------------------------------------------------*
31556 :h3. encoding of TAGGED SET (different order) (both elements are used), EXPLICIT TAGGING ENVIRONMENT
31557 .*---------------------------------------------------------------------*
31560 <TC - encoding of TAGGED SET (different order) (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
31576 b BOOLEAN OPTIONAL,
31585 import from TempA all;
31586 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31587 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31589 const BERPDU myValue := {
31598 if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
31602 Overall verdict: pass
31608 .*---------------------------------------------------------------------*
31609 :h3.CER + DER encoding of TAGGED SET (different order2) (both elements are used), EXPLICIT TAGGING ENVIRONMENT
31610 .*---------------------------------------------------------------------*
31613 <TC - CER + DER encoding of TAGGED SET (different order2) (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
31629 c INTEGER OPTIONAL,
31638 import from TempA all;
31639 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31640 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31642 const BERPDU myValue := {b := true,
31650 if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
31654 Overall verdict: pass
31660 .*---------------------------------------------------------------------*
31661 :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used)
31662 .*---------------------------------------------------------------------*
31665 <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used)>
31676 b [0] BOOLEAN OPTIONAL,
31677 c [1] INTEGER OPTIONAL
31685 import from TempA all;
31686 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31687 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31689 const BERPDU myValue := {b := true,
31697 if ((enc_DER_PDU(myValue) == 'A00C310AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803180A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
31701 Overall verdict: pass
31707 .*---------------------------------------------------------------------*
31708 :h3. encoding of TAGGED SET (both elements are TAGGED and used)
31709 .*---------------------------------------------------------------------*
31712 <TC - encoding of TAGGED SET (both elements are TAGGED and used)>
31723 b [0] BOOLEAN OPTIONAL,
31724 c [1] INTEGER OPTIONAL
31732 import from TempA all;
31733 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31734 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31736 const BERPDU myValue := {
31745 if ((enc_DER_PDU(myValue) == 'A00C310AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803180A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
31749 Overall verdict: pass
31755 .*---------------------------------------------------------------------*
31756 :h3.CER + DER encoding of TAGGED SET (different order) (both elements are TAGGED and used)
31757 .*---------------------------------------------------------------------*
31760 <TC - CER + DER encoding of TAGGED SET (different order) (both elements are TAGGED and used)>
31771 b [1] BOOLEAN OPTIONAL,
31772 c [0] INTEGER OPTIONAL
31780 import from TempA all;
31781 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31782 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31784 const BERPDU myValue := {b := true,
31792 if ((enc_DER_PDU(myValue) == 'A00C310AA003020105A1030101FF'O)and(enc_CER_PDU(myValue) == 'A0803180A0800201050000A1800101FF000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
31796 Overall verdict: pass
31802 .*---------------------------------------------------------------------*
31803 :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
31804 .*---------------------------------------------------------------------*
31807 <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
31823 b [0] BOOLEAN OPTIONAL,
31824 c [1] INTEGER OPTIONAL
31832 import from TempA all;
31833 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31834 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31836 const BERPDU myValue := {b := true,
31844 if ((enc_DER_PDU(myValue) == 'A00C310AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803180A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
31848 Overall verdict: pass
31854 .*---------------------------------------------------------------------*
31855 :h3. encoding of TAGGED SET (different order)(both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
31856 .*---------------------------------------------------------------------*
31859 <TC - encoding of TAGGED SET (different order)(both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
31875 b [0] BOOLEAN OPTIONAL,
31876 c [1] INTEGER OPTIONAL
31884 import from TempA all;
31885 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31886 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31888 const BERPDU myValue := {
31897 if ((enc_DER_PDU(myValue) == 'A00C310AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803180A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
31901 Overall verdict: pass
31907 .*---------------------------------------------------------------------*
31908 :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
31909 .*---------------------------------------------------------------------*
31912 <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
31928 b [1] BOOLEAN OPTIONAL,
31929 c [0] INTEGER OPTIONAL
31937 import from TempA all;
31938 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31939 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31941 const BERPDU myValue := {b := true,
31949 if ((enc_DER_PDU(myValue) == 'A00C310AA003020105A1030101FF'O)and(enc_CER_PDU(myValue) == 'A0803180A0800201050000A1800101FF000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
31953 Overall verdict: pass
31959 .*---------------------------------------------------------------------*
31960 :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
31961 .*---------------------------------------------------------------------*
31964 <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
31980 b [0] BOOLEAN OPTIONAL,
31981 c [1] INTEGER OPTIONAL
31989 import from TempA all;
31990 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31991 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31993 const BERPDU myValue := {b := true,
32001 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
32005 Overall verdict: pass
32011 .*---------------------------------------------------------------------*
32012 :h3. encoding of TAGGED SET (different order) (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
32013 .*---------------------------------------------------------------------*
32016 <TC - encoding of TAGGED SET (different order) (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
32032 b [0] BOOLEAN OPTIONAL,
32033 c [1] INTEGER OPTIONAL
32041 import from TempA all;
32042 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32043 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32045 const BERPDU myValue := {
32054 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
32058 Overall verdict: pass
32064 .*---------------------------------------------------------------------*
32065 :h3.CER + DER encoding of TAGGED SET (different order2)(both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
32066 .*---------------------------------------------------------------------*
32069 <TC - CER + DER encoding of TAGGED SET (different order2)(both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
32086 c [1] INTEGER OPTIONAL,
32087 b [0] BOOLEAN OPTIONAL
32095 import from TempA all;
32096 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32097 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32099 const BERPDU myValue := {b := true,
32107 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
32111 Overall verdict: pass
32117 .*---------------------------------------------------------------------*
32118 :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
32119 .*---------------------------------------------------------------------*
32122 <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
32138 b [0] BOOLEAN OPTIONAL,
32139 c [1] INTEGER OPTIONAL
32147 import from TempA all;
32148 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32149 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32151 const BERPDU myValue := {b := true,
32159 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
32164 Overall verdict: pass
32170 .*---------------------------------------------------------------------*
32171 :h3.encoding of TAGGED SET (different order) (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
32172 .*---------------------------------------------------------------------*
32175 <TC - encoding of TAGGED SET (different order) (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
32191 b [0] BOOLEAN OPTIONAL,
32192 c [1] INTEGER OPTIONAL
32200 import from TempA all;
32201 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32202 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32204 const BERPDU myValue := {
32213 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
32218 Overall verdict: pass
32224 .*---------------------------------------------------------------------*
32225 :h3.CER + DER encoding of TAGGED SET (different order2) (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
32226 .*---------------------------------------------------------------------*
32229 <TC - CER + DER encoding of TAGGED SET (different order2) (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
32246 c [0] INTEGER OPTIONAL,
32247 b [1] BOOLEAN OPTIONAL
32255 import from TempA all;
32256 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32257 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32259 const BERPDU myValue := {b := true,
32267 if ((enc_DER_PDU(myValue) == 'A0068001058101FF'O)and(enc_CER_PDU(myValue) == 'A0808001058101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
32272 Overall verdict: pass
32278 .*---------------------------------------------------------------------*
32279 :h3.CER + DER encoding of SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
32280 .*---------------------------------------------------------------------*
32283 <TC - CER + DER encoding of SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
32299 b [5] BOOLEAN OPTIONAL,
32308 import from TempA all;
32309 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32310 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32312 const BERPDU myValue := {b := true,
32320 if ((enc_DER_PDU(myValue) == '31060201058501FF'O)and(enc_CER_PDU(myValue) == '31800201058501FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
32324 Overall verdict: pass
32330 .*---------------------------------------------------------------------*
32331 :h3. encoding of SET , (different order) one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
32332 .*---------------------------------------------------------------------*
32335 <TC - encoding of SET , (different order) one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
32351 b [5] BOOLEAN OPTIONAL,
32360 import from TempA all;
32361 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32362 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32364 const BERPDU myValue := { c := 5 ,
32372 if ((enc_DER_PDU(myValue) == '31060201058501FF'O)and(enc_CER_PDU(myValue) == '31800201058501FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
32376 Overall verdict: pass
32382 .*---------------------------------------------------------------------*
32383 :h3.CER + DER encoding of SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
32384 .*---------------------------------------------------------------------*
32387 <TC - CER + DER encoding of SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
32403 {x INTEGER OPTIONAL,
32410 b BOOLEAN OPTIONAL,
32411 c INTEGER OPTIONAL,
32412 COMPONENTS OF MySeq
32420 import from TempA all;
32421 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32422 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32424 const BERPDU myValue := {b := true,
32434 if ((enc_DER_PDU(myValue) == '310C8001FF8101058201068301FF'O)and(enc_CER_PDU(myValue) == '31808001FF8101058201068301FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
32438 Overall verdict: pass
32444 .*---------------------------------------------------------------------*
32445 :h3. encoding of SET (different order) ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
32446 .*---------------------------------------------------------------------*
32449 <TC - encoding of SET (different order) ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
32474 b BOOLEAN OPTIONAL,
32475 c INTEGER OPTIONAL,
32476 COMPONENTS OF MySeq
32484 import from TempA all;
32485 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32486 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32488 const BERPDU myValue := {b := true,
32498 if ((enc_DER_PDU(myValue) == '310C8001FF8101058201FF830106'O)and(enc_CER_PDU(myValue) == '31808001FF8101058201FF8301060000'O)) {setverdict(pass);} else {setverdict(fail);}
32502 Overall verdict: pass
32508 .*---------------------------------------------------------------------*
32509 :h3.CER + DER encoding of SET , one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
32510 .*---------------------------------------------------------------------*
32513 <TC - CER + DER encoding of SET , one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
32528 {x [0] INTEGER OPTIONAL,
32535 b BOOLEAN OPTIONAL,
32536 c INTEGER OPTIONAL,
32537 COMPONENTS OF MySeq
32545 import from TempA all;
32546 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32547 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32549 const BERPDU myValue := {b := true,
32559 if ((enc_DER_PDU(myValue) == '310C8001FF8101058201068301FF'O)and(enc_CER_PDU(myValue) == '31808001FF8101058201068301FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
32563 Overall verdict: pass
32569 .*---------------------------------------------------------------------*
32570 :h3.CER + DER encoding of SET , (different order) one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
32571 .*---------------------------------------------------------------------*
32574 <TC - CER + DER encoding of SET , (different order) one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
32591 x [0] INTEGER OPTIONAL
32598 b BOOLEAN OPTIONAL,
32599 c INTEGER OPTIONAL,
32600 COMPONENTS OF MySeq
32608 import from TempA all;
32609 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32610 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32612 const BERPDU myValue := {b := true,
32622 if ((enc_DER_PDU(myValue) == '310C8001FF8101058201FF830106'O)and(enc_CER_PDU(myValue) == '31808001FF8101058201FF8301060000'O)) {setverdict(pass);} else {setverdict(fail);}
32626 Overall verdict: pass
32632 .*---------------------------------------------------------------------*
32633 :h3.CER + DER encoding of SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
32634 .*---------------------------------------------------------------------*
32637 <TC - CER + DER encoding of SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
32653 {x INTEGER OPTIONAL,
32660 b [0] BOOLEAN OPTIONAL,
32661 c BIT STRING OPTIONAL,
32662 COMPONENTS OF MySeq
32670 import from TempA all;
32671 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32672 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32674 const BERPDU myValue := {b := true,
32684 if ((enc_DER_PDU(myValue) == '310D020106030207800401FF8001FF'O)and(enc_CER_PDU(myValue) == '3180020106030207800401FF8001FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
32688 Overall verdict: pass
32694 .*---------------------------------------------------------------------*
32695 :h3.CER + DER encoding of SET , (different order)one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
32696 .*---------------------------------------------------------------------*
32699 <TC - CER + DER encoding of SET , (different order)one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
32723 b [0] BOOLEAN OPTIONAL,
32724 c BIT STRING OPTIONAL,
32725 COMPONENTS OF MySeq
32733 import from TempA all;
32734 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32735 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32737 const BERPDU myValue := {b := true,
32747 if ((enc_DER_PDU(myValue) == '310D020106030207800401FF8001FF'O)and(enc_CER_PDU(myValue) == '3180020106030207800401FF8001FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
32751 Overall verdict: pass
32757 .*---------------------------------------------------------------------*
32758 :h3.CER + DER encoding of SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
32759 .*---------------------------------------------------------------------*
32762 <TC - CER + DER encoding of SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
32777 {x [1] INTEGER OPTIONAL,
32784 b [0] BOOLEAN OPTIONAL,
32785 c BIT STRING OPTIONAL,
32786 COMPONENTS OF MySeq
32795 import from TempA all;
32796 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32797 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32799 const BERPDU myValue := {b := true,
32809 if ((enc_DER_PDU(myValue) == '310D030207800401FF8001FF810106'O)and(enc_CER_PDU(myValue) == '3180030207800401FF8001FF8101060000'O)) {setverdict(pass);} else {setverdict(fail);}
32813 Overall verdict: pass
32819 .*---------------------------------------------------------------------*
32820 :h3.CER + DER encoding of SET ,(different order) one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
32821 .*---------------------------------------------------------------------*
32824 <TC - CER + DER encoding of SET ,(different order) one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
32840 x [1] INTEGER OPTIONAL
32847 b [0] BOOLEAN OPTIONAL,
32848 c BIT STRING OPTIONAL,
32849 COMPONENTS OF MySeq
32858 import from TempA all;
32859 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32860 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32862 const BERPDU myValue := {b := true,
32872 if ((enc_DER_PDU(myValue) == '310D030207800401FF8001FF810106'O)and(enc_CER_PDU(myValue) == '3180030207800401FF8001FF8101060000'O)) {setverdict(pass);} else {setverdict(fail);}
32876 Overall verdict: pass
32882 .*---------------------------------------------------------------------*
32883 :h3.CER + DER encoding of SET with CHOICE element, AUTOMATIC TAGS
32884 .*---------------------------------------------------------------------*
32887 <TC - CER + DER encoding of SET with CHOICE element, AUTOMATIC TAGS>
32923 import from TempA all;
32924 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32925 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32927 const BERPDU myValue := {b := {x := true},
32935 if ((enc_DER_PDU(myValue) == '3108A0038001FF810104'O)and(enc_CER_PDU(myValue) == '3180A0808001FF00008101040000'O)) {setverdict(pass);} else {setverdict(fail);}
32939 Overall verdict: pass
32945 .*---------------------------------------------------------------------*
32946 :h3. encoding of SET with CHOICE element (different order), AUTOMATIC TAGS
32947 .*---------------------------------------------------------------------*
32950 <TC - encoding of SET with CHOICE element (different order), AUTOMATIC TAGS>
32986 import from TempA all;
32987 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32988 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32990 const BERPDU myValue := {
32998 if ((enc_DER_PDU(myValue) == '3108A0038001FF810104'O)and(enc_CER_PDU(myValue) == '3180A0808001FF00008101040000'O)) {setverdict(pass);} else {setverdict(fail);}
33002 Overall verdict: pass
33008 .*---------------------------------------------------------------------*
33009 :h3. encoding of SET with CHOICE element (different order2), AUTOMATIC TAGS
33010 .*---------------------------------------------------------------------*
33013 <TC - encoding of SET with CHOICE element (different order2), AUTOMATIC TAGS>
33034 c INTEGER OPTIONAL,
33049 import from TempA all;
33050 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33051 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33053 const BERPDU myValue := {
33061 if ((enc_DER_PDU(myValue) == '3108800104A1038001FF'O)and(enc_CER_PDU(myValue) == '3180800104A1808001FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
33065 Overall verdict: pass
33071 .*---------------------------------------------------------------------*
33072 :h3.CER + DER encoding of SET with CHOICE element,
33073 .*---------------------------------------------------------------------*
33076 <TC - CER + DER encoding of SET with CHOICE element, >
33112 import from TempA all;
33113 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33114 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33116 const BERPDU myValue := {b := {x := true},
33124 if ((enc_DER_PDU(myValue) == '31060101FF020104'O)and(enc_CER_PDU(myValue) == '31800101FF0201040000'O)) {setverdict(pass);} else {setverdict(fail);}
33128 Overall verdict: pass
33134 .*---------------------------------------------------------------------*
33135 :h3. encoding of SET with CHOICE element,(different order)
33136 .*---------------------------------------------------------------------*
33139 <TC - encoding of SET with CHOICE element,(different order) >
33175 import from TempA all;
33176 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33177 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33179 const BERPDU myValue := {
33188 if ((enc_DER_PDU(myValue) == '31060101FF020104'O)and(enc_CER_PDU(myValue) == '31800101FF0201040000'O)) {setverdict(pass);} else {setverdict(fail);}
33192 Overall verdict: pass
33198 .*---------------------------------------------------------------------*
33199 :h3.CER + DER encoding of SET with CHOICE element,
33200 .*---------------------------------------------------------------------*
33203 <TC - CER + DER encoding of SET with CHOICE element, >
33239 import from TempA all;
33240 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33241 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33243 const BERPDU myValue := {b := {y := 'FF'O},
33251 if ((enc_DER_PDU(myValue) == '31060201040401FF'O)and(enc_CER_PDU(myValue) == '31800401FF0201040000'O)) {setverdict(pass);} else {setverdict(fail);}
33255 Overall verdict: pass
33261 .*---------------------------------------------------------------------*
33262 :h3.CER + DER encoding of SET with EXTENSION , AUTOMATIC TAGS
33263 .*---------------------------------------------------------------------*
33266 <TC - CER + DER encoding of SET with EXTENSION , AUTOMATIC TAGS>
33290 c INTEGER OPTIONAL,
33307 import from TempA all;
33308 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33309 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33311 const BERPDU myValue := {
33322 if ((enc_DER_PDU(myValue) == '310D8001FF8101FF82010483020780'O)and(enc_CER_PDU(myValue) == '31808001FF8101FF820104830207800000'O)) {setverdict(pass);} else {setverdict(fail);}
33326 Overall verdict: pass
33332 .*---------------------------------------------------------------------*
33333 :h3. encoding of SET with EXTENSION , (different order) AUTOMATIC TAGS
33334 .*---------------------------------------------------------------------*
33337 <TC - encoding of SET with EXTENSION , (different order) AUTOMATIC TAGS>
33361 c INTEGER OPTIONAL,
33378 import from TempA all;
33379 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33380 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33382 const BERPDU myValue := {
33393 if ((enc_DER_PDU(myValue) == '310D8001FF8101FF82010483020780'O)and(enc_CER_PDU(myValue) == '31808001FF8101FF820104830207800000'O)) {setverdict(pass);} else {setverdict(fail);}
33397 Overall verdict: pass
33403 .*---------------------------------------------------------------------*
33404 :h3.CER + DER encoding of SET (EMPTY)
33405 .*---------------------------------------------------------------------*
33408 <TC - CER + DER encoding of SET (EMPTY)>
33422 d ENUMERATED {first ,second ,third},
33427 h OBJECT IDENTIFIER,
33429 j CHOICE {x1 [1] BOOLEAN,
33430 y1 [2] OCTET STRING},
33432 k SEQUENCE{x2 NULL,
33435 l SET { x3 BIT STRING,
33438 m [3] SEQUENCE OF INTEGER,
33439 n [4] SET OF BOOLEAN
33442 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
33449 import from TempA all;
33450 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33451 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33453 const BERPDU myValue := {a := NULL,
33462 j := {x1 := true } ,
33482 if ((enc_DER_PDU(myValue) == '31530101FF020102030207800402FFFF05000603000203090603312E452B300A0100300505000101FF310C03020780090603312E452B301603414243A1030101FFA3083006020101020102A40831060101FF0101FF'O)and(enc_CER_PDU(myValue) == '31800101FF020102030207800402FFFF05000603000203090603312E452B300A0100308005000101FF0000318003020780090603312E452B3000001603414243A1800101FF0000A380308002010102010200000000A48031800101FF0101FF000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
33486 Overall verdict: pass
33492 .*---------------------------------------------------------------------*
33493 :h3.CER + DER encoding of SET with fields of different types, AUTOMATIC TAGS
33494 .*---------------------------------------------------------------------*
33497 <TC - CER + DER encoding of SET with fields of different types, AUTOMATIC TAGS>
33516 d ENUMERATED {first ,second ,third},
33521 h OBJECT IDENTIFIER,
33523 j CHOICE {x1 BOOLEAN,
33526 k SEQUENCE{x2 NULL,
33529 l SET { x3 BIT STRING,
33532 m SEQUENCE OF INTEGER,
33537 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
33544 import from TempA all;
33545 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33546 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33548 const BERPDU myValue := {a := NULL,
33557 j := {x1 := true } ,
33579 if ((enc_DER_PDU(myValue) == '314F80008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB0C80020780810603312E452B30AC06020101020102AD060101FF0101FF'O)and(enc_CER_PDU(myValue) == '318080008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB8080020780810603312E452B300000AC800201010201020000AD800101FF0101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
33583 Overall verdict: pass
33589 .*---------------------------------------------------------------------*
33590 :h3.CER + DER encoding of SET with fields of different types (different order), AUTOMATIC TAGS
33591 .*---------------------------------------------------------------------*
33594 <TC - CER + DER encoding of SET with fields of different types (different order), AUTOMATIC TAGS>
33613 d ENUMERATED {first ,second ,third},
33618 h OBJECT IDENTIFIER,
33620 j CHOICE {x1 BOOLEAN,
33623 k SEQUENCE{x2 NULL,
33626 l SET { x3 BIT STRING,
33629 m SEQUENCE OF INTEGER,
33634 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
33641 import from TempA all;
33642 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33643 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33645 const BERPDU myValue := {a := NULL,
33654 j := {x1 := true } ,
33672 if ((enc_DER_PDU(myValue) == '314F80008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB0C80020780810603312E452B30AC06020101020102AD060101FF0101FF'O)and(enc_CER_PDU(myValue) == '318080008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB8080020780810603312E452B300000AC800201010201020000AD800101FF0101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
33676 Overall verdict: pass
33682 .*---------------------------------------------------------------------*
33683 :h3.CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGGING
33684 .*---------------------------------------------------------------------*
33687 <TC - CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGGING>
33704 d [PRIVATE 0] INTEGER OPTIONAL,
33705 a INTEGER OPTIONAL,
33706 b [APPLICATION 0] INTEGER OPTIONAL,
33707 c [0] INTEGER OPTIONAL
33716 import from TempA all;
33717 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33718 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33720 const BERPDU myValue := {
33731 if ((enc_DER_PDU(myValue) == '310C020101400102800103C00104'O)and(enc_CER_PDU(myValue) == '3180020101400102800103C001040000'O)) {setverdict(pass);} else {setverdict(fail);}
33735 Overall verdict: pass
33741 .*---------------------------------------------------------------------*
33742 :h3.CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )
33743 .*---------------------------------------------------------------------*
33746 <TC - CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )>
33761 d [PRIVATE 0] INTEGER OPTIONAL,
33762 a INTEGER OPTIONAL,
33763 b [APPLICATION 0] INTEGER OPTIONAL,
33764 c [0] INTEGER OPTIONAL
33773 import from TempA all;
33774 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33775 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33777 const BERPDU myValue := {
33788 if ((enc_DER_PDU(myValue) == '31120201016003020102A003020103E003020104'O)and(enc_CER_PDU(myValue) == '318002010160800201020000A0800201030000E08002010400000000'O)) {setverdict(pass);} else {setverdict(fail);}
33792 Overall verdict: pass
33798 .*---------------------------------------------------------------------*
33799 :h3.CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGGING
33800 .*---------------------------------------------------------------------*
33803 <TC - CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGGING>
33819 d [PRIVATE 0] INTEGER OPTIONAL,
33820 a INTEGER OPTIONAL,
33821 b [APPLICATION 0] INTEGER OPTIONAL,
33822 c [0] INTEGER OPTIONAL
33831 import from TempA all;
33832 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33833 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33835 const BERPDU myValue := {
33846 if ((enc_DER_PDU(myValue) == '31120201016003020102A003020103E003020104'O)and(enc_CER_PDU(myValue) == '318002010160800201020000A0800201030000E08002010400000000'O)) {setverdict(pass);} else {setverdict(fail);}
33850 Overall verdict: pass
33856 .*---------------------------------------------------------------------*
33857 :h3.CER + DER encoding of SET including untagged CHOICE (spec example) IMPLICIT TAGS
33858 .*---------------------------------------------------------------------*
33861 <TC - CER + DER encoding of SET including untagged CHOICE (spec example) IMPLICIT TAGS>
33905 import from TempA all;
33906 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33907 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33909 const BERPDU myValue := {
33912 e := { f := {g := 3 } }
33920 if ((enc_DER_PDU(myValue) == '310BA103820102830101850103'O)and(enc_CER_PDU(myValue) == '3180850103A18082010200008301010000'O)) {setverdict(pass);} else {setverdict(fail);}
33924 Overall verdict: pass
33930 .*---------------------------------------------------------------------*
33931 :h3.CER + DER encoding of SET including untagged CHOICE (spec example) EXPLICIT TAGS
33932 .*---------------------------------------------------------------------*
33935 <TC - CER + DER encoding of SET including untagged CHOICE (spec example) EXPLICIT TAGS>
33979 import from TempA all;
33980 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33981 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33983 const BERPDU myValue := {
33986 e := { f := { g := 3 } }
33994 if ((enc_DER_PDU(myValue) == '3111A105A203020102A303020101A503020103'O)and(enc_CER_PDU(myValue) == '3180A5800201030000A180A28002010200000000A38002010100000000'O)) {setverdict(pass);} else {setverdict(fail);}
33998 Overall verdict: pass
34004 .*---------------------------------------------------------------------*
34005 :h3. DECODING DER , SET (EMPTY)
34006 .*---------------------------------------------------------------------*
34009 <TC - DECODING DER , SET (EMPTY)>
34019 b BOOLEAN OPTIONAL,
34027 import from TempA all;
34029 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34032 const BERPDU myValue := {b := omit,
34037 if (dec_BER_PDU('3100'O) == myValue)
34041 {setverdict(pass);} else {setverdict(fail);}
34046 Overall verdict: pass
34052 .*---------------------------------------------------------------------*
34053 :h3. DECODING CER , SET (EMPTY)
34054 .*---------------------------------------------------------------------*
34057 <TC - DECODING CER , SET (EMPTY)>
34067 b BOOLEAN OPTIONAL,
34075 import from TempA all;
34077 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34080 const BERPDU myValue := {b := omit,
34085 if (dec_BER_PDU('31800000'O) == myValue)
34089 {setverdict(pass);} else {setverdict(fail);}
34094 Overall verdict: pass
34100 .*---------------------------------------------------------------------*
34101 :h3.DECODING DER , SET (only one element is used)
34102 .*---------------------------------------------------------------------*
34105 <TC - DECODING DER , SET (only one element is used)>
34115 b BOOLEAN OPTIONAL,
34124 import from TempA all;
34126 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34129 const BERPDU myValue := {b := true,
34134 if (dec_BER_PDU('31030101FF'O) == myValue)
34138 {setverdict(pass);} else {setverdict(fail);}
34143 Overall verdict: pass
34149 .*---------------------------------------------------------------------*
34150 :h3.DECODING CER , SET (only one element is used)
34151 .*---------------------------------------------------------------------*
34154 <TC - DECODING CER , SET (only one element is used)>
34164 b BOOLEAN OPTIONAL,
34173 import from TempA all;
34175 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34178 const BERPDU myValue := {b := true,
34183 if (dec_BER_PDU('31800101FF0000'O) == myValue)
34187 {setverdict(pass);} else {setverdict(fail);}
34192 Overall verdict: pass
34198 .*---------------------------------------------------------------------*
34199 :h3. DECODING DER , SET (both elements are used)
34200 .*---------------------------------------------------------------------*
34203 <TC - DECODING DER , SET (both elements are used)>
34213 b BOOLEAN OPTIONAL,
34222 import from TempA all;
34224 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34227 const BERPDU myValue := {b := true,
34233 if (dec_BER_PDU('31060101FF020105'O) == myValue)
34237 {setverdict(pass);} else {setverdict(fail);}
34242 Overall verdict: pass
34248 .*---------------------------------------------------------------------*
34249 :h3. DECODING CER , SET (both elements are used)
34250 .*---------------------------------------------------------------------*
34253 <TC - DECODING CER , SET (both elements are used)>
34263 b BOOLEAN OPTIONAL,
34272 import from TempA all;
34274 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34277 const BERPDU myValue := {b := true,
34283 if (dec_BER_PDU('31800101FF0201050000'O) == myValue)
34287 {setverdict(pass);} else {setverdict(fail);}
34292 Overall verdict: pass
34298 .*---------------------------------------------------------------------*
34299 :h3. DECODING ,different order , SET (both elements are used)
34300 .*---------------------------------------------------------------------*
34303 <TC - DECODING ,different order , SET (both elements are used)>
34314 c INTEGER OPTIONAL,
34323 import from TempA all;
34325 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34328 const BERPDU myValue := {b := true,
34334 if (dec_BER_PDU('31060201050101FF'O) == myValue)
34338 {setverdict(pass);} else {setverdict(fail);}
34343 Overall verdict: pass
34349 .*---------------------------------------------------------------------*
34350 :h3. DECODING , different order, SET (both elements are used)
34351 .*---------------------------------------------------------------------*
34354 <TC - DECODING , different order, SET (both elements are used)>
34365 c INTEGER OPTIONAL,
34374 import from TempA all;
34376 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34379 const BERPDU myValue := {
34386 if (dec_BER_PDU('31800201050101FF0000'O) == myValue)
34390 {setverdict(pass);} else {setverdict(fail);}
34395 Overall verdict: pass
34401 .*---------------------------------------------------------------------*
34402 :h3. DECODING DER , SET (one element is equal to Default)
34403 .*---------------------------------------------------------------------*
34406 <TC - DECODING DER , SET (one element is equal to Default)>
34416 b BOOLEAN DEFAULT TRUE,
34424 import from TempA all;
34426 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34429 const BERPDU myValue := {b := true,
34433 if (dec_BER_PDU('3103020105'O) == myValue)
34437 {setverdict(pass);} else {setverdict(fail);}
34442 Overall verdict: pass
34448 .*---------------------------------------------------------------------*
34449 :h3. DECODING CER, SET (one element is equal to Default)
34450 .*---------------------------------------------------------------------*
34453 <TC - DECODING CER, SET (one element is equal to Default)>
34463 b BOOLEAN DEFAULT TRUE,
34471 import from TempA all;
34473 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34476 const BERPDU myValue := {b := true,
34480 if (dec_BER_PDU('31800201050000'O) == myValue)
34484 {setverdict(pass);} else {setverdict(fail);}
34489 Overall verdict: pass
34495 .*---------------------------------------------------------------------*
34496 :h3. DECODING, default included , SET (one element is equal to Default)
34497 .*---------------------------------------------------------------------*
34500 <TC - DECODING, default included , SET (one element is equal to Default)>
34510 b BOOLEAN DEFAULT TRUE,
34518 import from TempA all;
34520 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34523 const BERPDU myValue := {b := true,
34527 if (dec_BER_PDU('31060201050101FF'O) == myValue)
34531 {setverdict(pass);} else {setverdict(fail);}
34536 Overall verdict: pass
34542 .*---------------------------------------------------------------------*
34543 :h3. DECODING , default included, SET (one element is equal to Default)
34544 .*---------------------------------------------------------------------*
34547 <TC - DECODING , default included, SET (one element is equal to Default)>
34557 b BOOLEAN DEFAULT TRUE,
34565 import from TempA all;
34567 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34570 const BERPDU myValue := {b := true,
34574 if (dec_BER_PDU('31800101FF0201050000'O) == myValue)
34578 {setverdict(pass);} else {setverdict(fail);}
34583 Overall verdict: pass
34589 .*---------------------------------------------------------------------*
34590 :h3. DECODING DER , SET (one element is not equal to Default)
34591 .*---------------------------------------------------------------------*
34594 <TC - DECODING DER , SET (one element is not equal to Default)>
34605 b BOOLEAN DEFAULT TRUE,
34614 import from TempA all;
34616 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34619 const BERPDU myValue := {b := false,
34623 if (dec_BER_PDU('3106010100020105'O) == myValue)
34627 {setverdict(pass);} else {setverdict(fail);}
34632 Overall verdict: pass
34638 .*---------------------------------------------------------------------*
34639 :h3. DECODING CER , SET (one element is not equal to Default)
34640 .*---------------------------------------------------------------------*
34643 <TC - DECODING CER , SET (one element is not equal to Default)>
34654 b BOOLEAN DEFAULT TRUE,
34663 import from TempA all;
34665 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34668 const BERPDU myValue := {b := false,
34672 if (dec_BER_PDU('31800101000201050000'O) == myValue)
34676 {setverdict(pass);} else {setverdict(fail);}
34681 Overall verdict: pass
34687 .*---------------------------------------------------------------------*
34688 :h3. DECODING, reverse order , SET (one element is not equal to Default)
34689 .*---------------------------------------------------------------------*
34692 <TC - DECODING, reverse order , SET (one element is not equal to Default)>
34703 b BOOLEAN DEFAULT TRUE,
34712 import from TempA all;
34714 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34717 const BERPDU myValue := {b := false,
34721 if (dec_BER_PDU('3106020105010100'O) == myValue)
34725 {setverdict(pass);} else {setverdict(fail);}
34730 Overall verdict: pass
34736 .*---------------------------------------------------------------------*
34737 :h3. DECODING ,reverse order , SET (one element is not equal to Default)
34738 .*---------------------------------------------------------------------*
34741 <TC - DECODING ,reverse order , SET (one element is not equal to Default)>
34752 b BOOLEAN DEFAULT TRUE,
34761 import from TempA all;
34763 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34766 const BERPDU myValue := {b := false,
34770 if (dec_BER_PDU('31800201050101000000'O) == myValue)
34774 {setverdict(pass);} else {setverdict(fail);}
34779 Overall verdict: pass
34785 .*---------------------------------------------------------------------*
34786 :h3. DECODING DER , SET (EMPTY), AUTOMATIC TAGGING
34787 .*---------------------------------------------------------------------*
34790 <TC - DECODING DER , SET (EMPTY), AUTOMATIC TAGGING>
34807 b BOOLEAN OPTIONAL,
34816 import from TempA all;
34818 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34821 const BERPDU myValue := {b := omit,
34826 if (dec_BER_PDU('3100'O) == myValue)
34830 {setverdict(pass);} else {setverdict(fail);}
34835 Overall verdict: pass
34841 .*---------------------------------------------------------------------*
34842 :h3. DECODING CER , SET (EMPTY), AUTOMATIC TAGGING
34843 .*---------------------------------------------------------------------*
34846 <TC - DECODING CER , SET (EMPTY), AUTOMATIC TAGGING>
34863 b BOOLEAN OPTIONAL,
34872 import from TempA all;
34874 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34877 const BERPDU myValue := {b := omit,
34882 if (dec_BER_PDU('31800000'O) == myValue)
34886 {setverdict(pass);} else {setverdict(fail);}
34891 Overall verdict: pass
34897 .*---------------------------------------------------------------------*
34898 :h3. DECODING DER , SET (only one element is used) AUTOMATIC TAGGING
34899 .*---------------------------------------------------------------------*
34902 <TC - DECODING DER , SET (only one element is used) AUTOMATIC TAGGING>
34920 b BOOLEAN OPTIONAL,
34929 import from TempA all;
34931 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34934 const BERPDU myValue := {b := true,
34939 if (dec_BER_PDU('31038001FF'O) == myValue)
34943 {setverdict(pass);} else {setverdict(fail);}
34948 Overall verdict: pass
34954 .*---------------------------------------------------------------------*
34955 :h3. DECODING CER , SET (only one element is used) AUTOMATIC TAGGING
34956 .*---------------------------------------------------------------------*
34959 <TC - DECODING CER , SET (only one element is used) AUTOMATIC TAGGING>
34977 b BOOLEAN OPTIONAL,
34986 import from TempA all;
34988 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34991 const BERPDU myValue := {b := true,
34996 if (dec_BER_PDU('31808001FF0000'O) == myValue)
35000 {setverdict(pass);} else {setverdict(fail);}
35005 Overall verdict: pass
35011 .*---------------------------------------------------------------------*
35012 :h3. DECODING DER , SET (both elements are used) AUTOMATIC TAGGING
35013 .*---------------------------------------------------------------------*
35016 <TC - DECODING DER , SET (both elements are used) AUTOMATIC TAGGING>
35034 b BOOLEAN OPTIONAL,
35044 import from TempA all;
35046 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35049 const BERPDU myValue := {b := true,
35054 if (dec_BER_PDU('31068001FF810105'O) == myValue)
35058 {setverdict(pass);} else {setverdict(fail);}
35063 Overall verdict: pass
35069 .*---------------------------------------------------------------------*
35070 :h3. DECODING CER , SET (both elements are used) AUTOMATIC TAGGING
35071 .*---------------------------------------------------------------------*
35074 <TC - DECODING CER , SET (both elements are used) AUTOMATIC TAGGING>
35092 b BOOLEAN OPTIONAL,
35102 import from TempA all;
35104 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35107 const BERPDU myValue := {b := true,
35112 if (dec_BER_PDU('31808001FF8101050000'O) == myValue)
35116 {setverdict(pass);} else {setverdict(fail);}
35121 Overall verdict: pass
35127 .*---------------------------------------------------------------------*
35128 :h3. DECODING ,reverse order , SET (both elements are used) AUTOMATIC TAGGING
35129 .*---------------------------------------------------------------------*
35132 <TC - DECODING ,reverse order , SET (both elements are used) AUTOMATIC TAGGING>
35150 b BOOLEAN OPTIONAL,
35160 import from TempA all;
35162 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35165 const BERPDU myValue := {b := true,
35170 if (dec_BER_PDU('31068101058001FF'O) == myValue)
35174 {setverdict(pass);} else {setverdict(fail);}
35179 Overall verdict: pass
35185 .*---------------------------------------------------------------------*
35186 :h3. DECODING, reverse order , SET (both elements are used) AUTOMATIC TAGGING
35187 .*---------------------------------------------------------------------*
35190 <TC - DECODING, reverse order , SET (both elements are used) AUTOMATIC TAGGING>
35208 b BOOLEAN OPTIONAL,
35218 import from TempA all;
35220 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35223 const BERPDU myValue := {b := true,
35228 if (dec_BER_PDU('31808101058001FF0000'O) == myValue)
35232 {setverdict(pass);} else {setverdict(fail);}
35237 Overall verdict: pass
35243 .*---------------------------------------------------------------------*
35244 :h3. DECODING DER , SET (one element is equal to Default) AUTOMATIC TAGGING
35245 .*---------------------------------------------------------------------*
35248 <TC - DECODING DER , SET (one element is equal to Default) AUTOMATIC TAGGING >
35266 b BOOLEAN DEFAULT TRUE,
35276 import from TempA all;
35278 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35281 const BERPDU myValue := {b := true,
35286 if (dec_BER_PDU('3103810105'O) == myValue)
35290 {setverdict(pass);} else {setverdict(fail);}
35295 Overall verdict: pass
35301 .*---------------------------------------------------------------------*
35302 :h3. DECODING CER , SET (one element is equal to Default) AUTOMATIC TAGGING
35303 .*---------------------------------------------------------------------*
35306 <TC - DECODING CER , SET (one element is equal to Default) AUTOMATIC TAGGING >
35324 b BOOLEAN DEFAULT TRUE,
35334 import from TempA all;
35336 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35339 const BERPDU myValue := {b := true,
35344 if (dec_BER_PDU('31808101050000'O) == myValue)
35348 {setverdict(pass);} else {setverdict(fail);}
35353 Overall verdict: pass
35359 .*---------------------------------------------------------------------*
35360 :h3. DECODING , default included , SET (one element is equal to Default) AUTOMATIC TAGGING
35361 .*---------------------------------------------------------------------*
35364 <TC - DECODING , default included , SET (one element is equal to Default) AUTOMATIC TAGGING >
35382 b BOOLEAN DEFAULT TRUE,
35392 import from TempA all;
35394 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35397 const BERPDU myValue := {b := true,
35402 if (dec_BER_PDU('31068001FF810105'O) == myValue)
35406 {setverdict(pass);} else {setverdict(fail);}
35411 Overall verdict: pass
35417 .*---------------------------------------------------------------------*
35418 :h3. DECODING , default included, SET (one element is equal to Default) AUTOMATIC TAGGING
35419 .*---------------------------------------------------------------------*
35422 <TC - DECODING , default included, SET (one element is equal to Default) AUTOMATIC TAGGING >
35440 b BOOLEAN DEFAULT TRUE,
35450 import from TempA all;
35452 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35455 const BERPDU myValue := {b := true,
35460 if (dec_BER_PDU('31808101058001FF0000'O) == myValue)
35464 {setverdict(pass);} else {setverdict(fail);}
35469 Overall verdict: pass
35475 .*---------------------------------------------------------------------*
35476 :h3. DECODING DER ,SET (one element is not equal to Default) AUTOMATIC TAGGING
35477 .*---------------------------------------------------------------------*
35480 <TC - DECODING DER ,SET (one element is not equal to Default) AUTOMATIC TAGGING>
35498 b BOOLEAN DEFAULT TRUE,
35508 import from TempA all;
35510 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35513 const BERPDU myValue := {b := false,
35518 if (dec_BER_PDU('3106800100810105'O) == myValue)
35522 {setverdict(pass);} else {setverdict(fail);}
35527 Overall verdict: pass
35533 .*---------------------------------------------------------------------*
35534 :h3. DECODING CER ,SET (one element is not equal to Default) AUTOMATIC TAGGING
35535 .*---------------------------------------------------------------------*
35538 <TC - DECODING CER ,SET (one element is not equal to Default) AUTOMATIC TAGGING>
35556 b BOOLEAN DEFAULT TRUE,
35566 import from TempA all;
35568 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35571 const BERPDU myValue := {b := false,
35576 if (dec_BER_PDU('31808001008101050000'O) == myValue)
35580 {setverdict(pass);} else {setverdict(fail);}
35585 Overall verdict: pass
35591 .*---------------------------------------------------------------------*
35592 :h3. DECODING,reverse order,SET (one element is not equal to Default) AUTOMATIC TAGGING
35593 .*---------------------------------------------------------------------*
35596 <TC - DECODING,reverse order,SET (one element is not equal to Default) AUTOMATIC TAGGING>
35614 b BOOLEAN DEFAULT TRUE,
35624 import from TempA all;
35626 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35629 const BERPDU myValue := {b := false,
35634 if (dec_BER_PDU('3106810105800100'O) == myValue)
35638 {setverdict(pass);} else {setverdict(fail);}
35643 Overall verdict: pass
35649 .*---------------------------------------------------------------------*
35650 :h3. DECODING CER ,SET (one element is not equal to Default) AUTOMATIC TAGGING
35651 .*---------------------------------------------------------------------*
35654 <TC - DECODING CER ,SET (one element is not equal to Default) AUTOMATIC TAGGING>
35672 b BOOLEAN DEFAULT TRUE,
35682 import from TempA all;
35684 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35687 const BERPDU myValue := {b := false,
35692 if (dec_BER_PDU('31808101058001000000'O) == myValue)
35696 {setverdict(pass);} else {setverdict(fail);}
35701 Overall verdict: pass
35707 .*---------------------------------------------------------------------*
35708 :h3. DECODING DER , SET (both elements are used) IMPLICIT TAGS for elements
35709 .*---------------------------------------------------------------------*
35712 <TC - DECODING DER , SET (both elements are used) IMPLICIT TAGS for elements>
35730 b [30] IMPLICIT BOOLEAN OPTIONAL,
35731 c [31] IMPLICIT INTEGER OPTIONAL
35739 import from TempA all;
35741 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35744 const BERPDU myValue := {b := true,
35749 if (dec_BER_PDU('31079E01FF9F1F0105'O) == myValue)
35753 {setverdict(pass);} else {setverdict(fail);}
35758 Overall verdict: pass
35764 .*---------------------------------------------------------------------*
35765 :h3. DECODING CER , SET (both elements are used) IMPLICIT TAGS for elements
35766 .*---------------------------------------------------------------------*
35769 <TC - DECODING CER , SET (both elements are used) IMPLICIT TAGS for elements>
35787 b [30] IMPLICIT BOOLEAN OPTIONAL,
35788 c [31] IMPLICIT INTEGER OPTIONAL
35796 import from TempA all;
35798 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35801 const BERPDU myValue := {b := true,
35806 if (dec_BER_PDU('31809E01FF9F1F01050000'O) == myValue)
35810 {setverdict(pass);} else {setverdict(fail);}
35815 Overall verdict: pass
35821 .*---------------------------------------------------------------------*
35822 :h3. DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements
35823 .*---------------------------------------------------------------------*
35826 <TC - DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements>
35844 b [30] IMPLICIT BOOLEAN OPTIONAL,
35845 c [31] IMPLICIT INTEGER OPTIONAL
35853 import from TempA all;
35855 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35858 const BERPDU myValue := {b := true,
35863 if (dec_BER_PDU('31079F1F01059E01FF'O) == myValue)
35867 {setverdict(pass);} else {setverdict(fail);}
35872 Overall verdict: pass
35878 .*---------------------------------------------------------------------*
35879 :h3. DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements
35880 .*---------------------------------------------------------------------*
35883 <TC - DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements>
35901 b [30] IMPLICIT BOOLEAN OPTIONAL,
35902 c [31] IMPLICIT INTEGER OPTIONAL
35910 import from TempA all;
35912 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35915 const BERPDU myValue := {b := true,
35920 if (dec_BER_PDU('31809F1F01059E01FF0000'O) == myValue)
35924 {setverdict(pass);} else {setverdict(fail);}
35929 Overall verdict: pass
35935 .*---------------------------------------------------------------------*
35936 :h3. DECODING DER , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
35937 .*---------------------------------------------------------------------*
35940 <TC - DECODING DER , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
35958 b [30] IMPLICIT BOOLEAN OPTIONAL,
35959 c [31] IMPLICIT INTEGER OPTIONAL
35968 import from TempA all;
35970 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35973 const BERPDU myValue := {b := true,
35979 if (dec_BER_PDU('31079E01FF9F1F0105'O) == myValue)
35983 {setverdict(pass);} else {setverdict(fail);}
35988 Overall verdict: pass
35994 .*---------------------------------------------------------------------*
35995 :h3. DECODING CER , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
35996 .*---------------------------------------------------------------------*
35999 <TC - DECODING CER , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
36017 b [30] IMPLICIT BOOLEAN OPTIONAL,
36018 c [31] IMPLICIT INTEGER OPTIONAL
36027 import from TempA all;
36029 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36032 const BERPDU myValue := {b := true,
36038 if (dec_BER_PDU('31809E01FF9F1F01050000'O) == myValue)
36042 {setverdict(pass);} else {setverdict(fail);}
36047 Overall verdict: pass
36053 .*---------------------------------------------------------------------*
36054 :h3. DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
36055 .*---------------------------------------------------------------------*
36058 <TC - DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
36076 b [30] IMPLICIT BOOLEAN OPTIONAL,
36077 c [31] IMPLICIT INTEGER OPTIONAL
36086 import from TempA all;
36088 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36091 const BERPDU myValue := {b := true,
36097 if (dec_BER_PDU('31079F1F01059E01FF'O) == myValue)
36101 {setverdict(pass);} else {setverdict(fail);}
36106 Overall verdict: pass
36112 .*---------------------------------------------------------------------*
36113 :h3. DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
36114 .*---------------------------------------------------------------------*
36117 <TC - DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
36135 b [30] IMPLICIT BOOLEAN OPTIONAL,
36136 c [31] IMPLICIT INTEGER OPTIONAL
36145 import from TempA all;
36147 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36150 const BERPDU myValue := {b := true,
36156 if (dec_BER_PDU('31809F1F01059E01FF0000'O) == myValue)
36160 {setverdict(pass);} else {setverdict(fail);}
36165 Overall verdict: pass
36171 .*---------------------------------------------------------------------*
36172 :h3. DECODING DER, SET (both elements are used) EXPLICIT TAGS for elements
36173 .*---------------------------------------------------------------------*
36176 <TC - DECODING DER, SET (both elements are used) EXPLICIT TAGS for elements>
36193 b [30] EXPLICIT BOOLEAN OPTIONAL,
36194 c [31] EXPLICIT INTEGER OPTIONAL
36203 import from TempA all;
36205 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36208 const BERPDU myValue := {b := true,
36214 if (dec_BER_PDU('310BBE030101FFBF1F03020105'O) == myValue)
36218 {setverdict(pass);} else {setverdict(fail);}
36223 Overall verdict: pass
36229 .*---------------------------------------------------------------------*
36230 :h3. DECODING CER, SET (both elements are used) EXPLICIT TAGS for elements
36231 .*---------------------------------------------------------------------*
36234 <TC - DECODING CER, SET (both elements are used) EXPLICIT TAGS for elements>
36251 b [30] EXPLICIT BOOLEAN OPTIONAL,
36252 c [31] EXPLICIT INTEGER OPTIONAL
36261 import from TempA all;
36263 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36266 const BERPDU myValue := {b := true,
36272 if (dec_BER_PDU('3180BE800101FF0000BF1F8002010500000000'O) == myValue)
36276 {setverdict(pass);} else {setverdict(fail);}
36281 Overall verdict: pass
36287 .*---------------------------------------------------------------------*
36288 :h3. DECODING , reverse order, SET (both elements are used) EXPLICIT TAGS for elements
36289 .*---------------------------------------------------------------------*
36292 <TC - DECODING , reverse order, SET (both elements are used) EXPLICIT TAGS for elements>
36309 b [30] EXPLICIT BOOLEAN OPTIONAL,
36310 c [31] EXPLICIT INTEGER OPTIONAL
36319 import from TempA all;
36321 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36324 const BERPDU myValue := {b := true,
36330 if (dec_BER_PDU('310BBF1F03020105BE030101FF'O) == myValue)
36334 {setverdict(pass);} else {setverdict(fail);}
36339 Overall verdict: pass
36345 .*---------------------------------------------------------------------*
36346 :h3. DECODING , reverse order, SET (both elements are used) EXPLICIT TAGS for elements
36347 .*---------------------------------------------------------------------*
36350 <TC - DECODING , reverse order, SET (both elements are used) EXPLICIT TAGS for elements>
36367 b [30] EXPLICIT BOOLEAN OPTIONAL,
36368 c [31] EXPLICIT INTEGER OPTIONAL
36377 import from TempA all;
36379 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36382 const BERPDU myValue := {b := true,
36388 if (dec_BER_PDU('3180BF1F800201050000BE800101FF00000000'O) == myValue)
36392 {setverdict(pass);} else {setverdict(fail);}
36397 Overall verdict: pass
36403 .*---------------------------------------------------------------------*
36404 :h3. DECODING DER , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
36405 .*---------------------------------------------------------------------*
36408 <TC - DECODING DER , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
36426 b [30] EXPLICIT BOOLEAN OPTIONAL,
36427 c [31] EXPLICIT INTEGER OPTIONAL
36435 import from TempA all;
36437 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36440 const BERPDU myValue := {b := true,
36447 if (dec_BER_PDU('310BBE030101FFBF1F03020105'O) == myValue)
36451 {setverdict(pass);} else {setverdict(fail);}
36456 Overall verdict: pass
36462 .*---------------------------------------------------------------------*
36463 :h3. DECODING CER , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
36464 .*---------------------------------------------------------------------*
36467 <TC - DECODING CER , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
36485 b [30] EXPLICIT BOOLEAN OPTIONAL,
36486 c [31] EXPLICIT INTEGER OPTIONAL
36494 import from TempA all;
36496 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36499 const BERPDU myValue := {b := true,
36506 if (dec_BER_PDU('3180BE800101FF0000BF1F8002010500000000'O) == myValue)
36510 {setverdict(pass);} else {setverdict(fail);}
36515 Overall verdict: pass
36521 .*---------------------------------------------------------------------*
36522 :h3. DECODING , reverse order , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
36523 .*---------------------------------------------------------------------*
36526 <TC - DECODING , reverse order , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
36544 b [30] EXPLICIT BOOLEAN OPTIONAL,
36545 c [31] EXPLICIT INTEGER OPTIONAL
36553 import from TempA all;
36555 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36558 const BERPDU myValue := {b := true,
36565 if (dec_BER_PDU('310BBF1F03020105BE030101FF'O) == myValue)
36569 {setverdict(pass);} else {setverdict(fail);}
36574 Overall verdict: pass
36580 .*---------------------------------------------------------------------*
36581 :h3. DECODING , reverse order , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
36582 .*---------------------------------------------------------------------*
36585 <TC - DECODING , reverse order , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
36603 b [30] EXPLICIT BOOLEAN OPTIONAL,
36604 c [31] EXPLICIT INTEGER OPTIONAL
36612 import from TempA all;
36614 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36617 const BERPDU myValue := {b := true,
36624 if (dec_BER_PDU('3180BF1F800201050000BE800101FF00000000'O) == myValue)
36628 {setverdict(pass);} else {setverdict(fail);}
36633 Overall verdict: pass
36639 .*---------------------------------------------------------------------*
36640 :h3. DECODING , DER , TAGGED SET (both elements are used)
36641 .*---------------------------------------------------------------------*
36644 <TC - DECODING , DER , TAGGED SET (both elements are used)>
36661 b BOOLEAN OPTIONAL,
36670 import from TempA all;
36672 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36675 const BERPDU myValue := {b := true,
36682 if (dec_BER_PDU('A00831060101FF020105'O) == myValue)
36686 {setverdict(pass);} else {setverdict(fail);}
36691 Overall verdict: pass
36697 .*---------------------------------------------------------------------*
36698 :h3. DECODING , CER , TAGGED SET (both elements are used)
36699 .*---------------------------------------------------------------------*
36702 <TC - DECODING , CER , TAGGED SET (both elements are used)>
36719 b BOOLEAN OPTIONAL,
36728 import from TempA all;
36730 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36733 const BERPDU myValue := {b := true,
36740 if (dec_BER_PDU('A08031800101FF02010500000000'O) == myValue)
36744 {setverdict(pass);} else {setverdict(fail);}
36749 Overall verdict: pass
36755 .*---------------------------------------------------------------------*
36756 :h3. DECODING , reverse order , TAGGED SET (both elements are used)
36757 .*---------------------------------------------------------------------*
36760 <TC - DECODING , reverse order , TAGGED SET (both elements are used)>
36777 b BOOLEAN OPTIONAL,
36786 import from TempA all;
36788 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36791 const BERPDU myValue := {b := true,
36798 if (dec_BER_PDU('A00831060201050101FF'O) == myValue)
36802 {setverdict(pass);} else {setverdict(fail);}
36807 Overall verdict: pass
36813 .*---------------------------------------------------------------------*
36814 :h3. DECODING ,reverse order , TAGGED SET (both elements are used)
36815 .*---------------------------------------------------------------------*
36818 <TC - DECODING ,reverse order , TAGGED SET (both elements are used)>
36835 b BOOLEAN OPTIONAL,
36844 import from TempA all;
36846 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36849 const BERPDU myValue := {b := true,
36856 if (dec_BER_PDU('A08031800201050101FF00000000'O) == myValue)
36860 {setverdict(pass);} else {setverdict(fail);}
36865 Overall verdict: pass
36871 .*---------------------------------------------------------------------*
36872 :h3. DECODING DER , TAGGED SEQUENCE (both elements are used)
36873 .*---------------------------------------------------------------------*
36876 <TC - DECODING DER , TAGGED SEQUENCE (both elements are used)>
36891 BERPDU ::= [0] SEQUENCE
36893 b BOOLEAN OPTIONAL,
36901 import from TempA all;
36903 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36906 const BERPDU myValue := {b := true,
36913 if (dec_BER_PDU('A00831060101FF020105'O) == myValue)
36917 {setverdict(pass);} else {setverdict(fail);}
36922 Overall verdict: pass
36928 .*---------------------------------------------------------------------*
36929 :h3. DECODING CER , TAGGED SET (both elements are used)
36930 .*---------------------------------------------------------------------*
36933 <TC - DECODING CER , TAGGED SET (both elements are used)>
36950 b BOOLEAN OPTIONAL,
36958 import from TempA all;
36960 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36963 const BERPDU myValue := {b := true,
36970 if (dec_BER_PDU('A08031800101FF02010500000000'O) == myValue)
36974 {setverdict(pass);} else {setverdict(fail);}
36979 Overall verdict: pass
36985 .*---------------------------------------------------------------------*
36986 :h3. DECODING , reverse order , TAGGED SEQUENCE (both elements are used)
36987 .*---------------------------------------------------------------------*
36990 <TC - DECODING , reverse order , TAGGED SEQUENCE (both elements are used)>
37005 BERPDU ::= [0] SEQUENCE
37007 b BOOLEAN OPTIONAL,
37015 import from TempA all;
37017 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37020 const BERPDU myValue := {b := true,
37027 if (dec_BER_PDU('A00831060101FF020105'O) == myValue)
37031 {setverdict(pass);} else {setverdict(fail);}
37036 Overall verdict: pass
37042 .*---------------------------------------------------------------------*
37043 :h3. DECODING , reverse order , TAGGED SET (both elements are used)
37044 .*---------------------------------------------------------------------*
37047 <TC - DECODING , reverse order , TAGGED SET (both elements are used)>
37064 b BOOLEAN OPTIONAL,
37072 import from TempA all;
37074 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37077 const BERPDU myValue := {b := true,
37084 if (dec_BER_PDU('A08031800201050101FF00000000'O) == myValue)
37088 {setverdict(pass);} else {setverdict(fail);}
37093 Overall verdict: pass
37099 .*---------------------------------------------------------------------*
37100 :h3. DECODING DER , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT
37101 .*---------------------------------------------------------------------*
37104 <TC - DECODING DER , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
37122 b BOOLEAN OPTIONAL,
37131 import from TempA all;
37133 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37136 const BERPDU myValue := {b := true,
37142 if (dec_BER_PDU('A0060101FF020105'O) == myValue)
37146 {setverdict(pass);} else {setverdict(fail);}
37151 Overall verdict: pass
37157 .*---------------------------------------------------------------------*
37158 :h3. DECODING CER , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT
37159 .*---------------------------------------------------------------------*
37162 <TC - DECODING CER , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
37180 b BOOLEAN OPTIONAL,
37189 import from TempA all;
37191 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37194 const BERPDU myValue := {b := true,
37200 if (dec_BER_PDU('A0800101FF0201050000'O) == myValue)
37204 {setverdict(pass);} else {setverdict(fail);}
37209 Overall verdict: pass
37215 .*---------------------------------------------------------------------*
37216 :h3. DECODING , reverse order , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT
37217 .*---------------------------------------------------------------------*
37220 <TC - DECODING , reverse order , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
37238 b BOOLEAN OPTIONAL,
37247 import from TempA all;
37249 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37252 const BERPDU myValue := {b := true,
37258 if (dec_BER_PDU('A0060201050101FF'O) == myValue)
37262 {setverdict(pass);} else {setverdict(fail);}
37267 Overall verdict: pass
37273 .*---------------------------------------------------------------------*
37274 :h3. DECODING, reverse order , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT
37275 .*---------------------------------------------------------------------*
37278 <TC - DECODING, reverse order , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
37296 b BOOLEAN OPTIONAL,
37305 import from TempA all;
37307 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37310 const BERPDU myValue := {b := true,
37316 if (dec_BER_PDU('A0800201050101FF0000'O) == myValue)
37320 {setverdict(pass);} else {setverdict(fail);}
37325 Overall verdict: pass
37331 .*---------------------------------------------------------------------*
37332 :h3. DECODING DER , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT
37333 .*---------------------------------------------------------------------*
37336 <TC - DECODING DER , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
37354 b BOOLEAN OPTIONAL,
37363 import from TempA all;
37365 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37368 const BERPDU myValue := {b := true,
37375 if (dec_BER_PDU('A00831060101FF020105'O) == myValue)
37379 {setverdict(pass);} else {setverdict(fail);}
37384 Overall verdict: pass
37390 .*---------------------------------------------------------------------*
37391 :h3. DECODING CER , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT
37392 .*---------------------------------------------------------------------*
37395 <TC - DECODING CER , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
37413 b BOOLEAN OPTIONAL,
37422 import from TempA all;
37424 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37427 const BERPDU myValue := {b := true,
37434 if (dec_BER_PDU('A08031800101FF02010500000000'O) == myValue)
37438 {setverdict(pass);} else {setverdict(fail);}
37443 Overall verdict: pass
37449 .*---------------------------------------------------------------------*
37450 :h3. DECODING, reverse order , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT
37451 .*---------------------------------------------------------------------*
37454 <TC - DECODING, reverse order , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
37472 b BOOLEAN OPTIONAL,
37481 import from TempA all;
37483 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37486 const BERPDU myValue := {b := true,
37493 if (dec_BER_PDU('A00831060201050101FF'O) == myValue)
37497 {setverdict(pass);} else {setverdict(fail);}
37502 Overall verdict: pass
37508 .*---------------------------------------------------------------------*
37509 :h3. DECODING, reverse order , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT
37510 .*---------------------------------------------------------------------*
37513 <TC - DECODING, reverse order , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
37531 b BOOLEAN OPTIONAL,
37540 import from TempA all;
37542 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37545 const BERPDU myValue := {b := true,
37552 if (dec_BER_PDU('A08031800201050101FF00000000'O) == myValue)
37556 {setverdict(pass);} else {setverdict(fail);}
37561 Overall verdict: pass
37567 .*---------------------------------------------------------------------*
37568 :h3. DECODING DER, TAGGED SET (both elements are TAGGED and used)
37569 .*---------------------------------------------------------------------*
37572 <TC - DECODING DER, TAGGED SET (both elements are TAGGED and used)>
37589 b [0] BOOLEAN OPTIONAL,
37590 c [1] INTEGER OPTIONAL
37599 import from TempA all;
37601 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37604 const BERPDU myValue := {b := true,
37611 if (dec_BER_PDU('A00C310AA0030101FFA103020105'O) == myValue)
37615 {setverdict(pass);} else {setverdict(fail);}
37620 Overall verdict: pass
37626 .*---------------------------------------------------------------------*
37627 :h3. DECODING CER, TAGGED SET (both elements are TAGGED and used)
37628 .*---------------------------------------------------------------------*
37631 <TC - DECODING CER, TAGGED SET (both elements are TAGGED and used)>
37648 b [0] BOOLEAN OPTIONAL,
37649 c [1] INTEGER OPTIONAL
37658 import from TempA all;
37660 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37663 const BERPDU myValue := {b := true,
37670 if (dec_BER_PDU('A0803180A0800101FF0000A180020105000000000000'O) == myValue)
37674 {setverdict(pass);} else {setverdict(fail);}
37679 Overall verdict: pass
37685 .*---------------------------------------------------------------------*
37686 :h3. DECODING reverse order, TAGGED SET (both elements are TAGGED and used)
37687 .*---------------------------------------------------------------------*
37690 <TC - DECODING reverse order, TAGGED SET (both elements are TAGGED and used)>
37707 b [0] BOOLEAN OPTIONAL,
37708 c [1] INTEGER OPTIONAL
37717 import from TempA all;
37719 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37722 const BERPDU myValue := {b := true,
37729 if (dec_BER_PDU('A00C310AA103020105A0030101FF'O) == myValue)
37733 {setverdict(pass);} else {setverdict(fail);}
37738 Overall verdict: pass
37744 .*---------------------------------------------------------------------*
37745 :h3. DECODING reverse order, TAGGED SET (both elements are TAGGED and used)
37746 .*---------------------------------------------------------------------*
37749 <TC - DECODING reverse order, TAGGED SET (both elements are TAGGED and used)>
37766 b [0] BOOLEAN OPTIONAL,
37767 c [1] INTEGER OPTIONAL
37776 import from TempA all;
37778 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37781 const BERPDU myValue := {b := true,
37788 if (dec_BER_PDU('A0803180A1800201050000A0800101FF000000000000'O) == myValue)
37792 {setverdict(pass);} else {setverdict(fail);}
37797 Overall verdict: pass
37803 .*---------------------------------------------------------------------*
37804 :h3. DECODING DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
37805 .*---------------------------------------------------------------------*
37808 <TC - DECODING DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
37826 b [0] BOOLEAN OPTIONAL,
37827 c [1] INTEGER OPTIONAL
37835 import from TempA all;
37837 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37840 const BERPDU myValue := {b := true,
37847 if (dec_BER_PDU('A00C310AA0030101FFA103020105'O) == myValue)
37851 {setverdict(pass);} else {setverdict(fail);}
37856 Overall verdict: pass
37862 .*---------------------------------------------------------------------*
37863 :h3. DECODING CER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
37864 .*---------------------------------------------------------------------*
37867 <TC - DECODING CER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
37885 b [0] BOOLEAN OPTIONAL,
37886 c [1] INTEGER OPTIONAL
37894 import from TempA all;
37896 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37899 const BERPDU myValue := {b := true,
37906 if (dec_BER_PDU('A0803180A0800101FF0000A180020105000000000000'O) == myValue)
37910 {setverdict(pass);} else {setverdict(fail);}
37915 Overall verdict: pass
37921 .*---------------------------------------------------------------------*
37922 :h3. DECODING ,reverse order, TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
37923 .*---------------------------------------------------------------------*
37926 <TC - DECODING ,reverse order, TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
37944 b [0] BOOLEAN OPTIONAL,
37945 c [1] INTEGER OPTIONAL
37953 import from TempA all;
37955 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37958 const BERPDU myValue := {b := true,
37965 if (dec_BER_PDU('A00C310AA103020105A0030101FF'O) == myValue)
37969 {setverdict(pass);} else {setverdict(fail);}
37974 Overall verdict: pass
37980 .*---------------------------------------------------------------------*
37981 :h3. DECODING, reverse order, TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
37982 .*---------------------------------------------------------------------*
37985 <TC - DECODING, reverse order, TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
38003 b [0] BOOLEAN OPTIONAL,
38004 c [1] INTEGER OPTIONAL
38012 import from TempA all;
38014 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38017 const BERPDU myValue := {b := true,
38024 if (dec_BER_PDU('A0803180A1800201050000A0800101FF000000000000'O) == myValue)
38028 {setverdict(pass);} else {setverdict(fail);}
38033 Overall verdict: pass
38039 .*---------------------------------------------------------------------*
38040 :h3. DECODING , DER , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
38041 .*---------------------------------------------------------------------*
38044 <TC - DECODING , DER , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
38062 b [0] BOOLEAN OPTIONAL,
38063 c [1] INTEGER OPTIONAL
38071 import from TempA all;
38073 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38076 const BERPDU myValue := {b := true,
38082 if (dec_BER_PDU('A0068001FF810105'O) == myValue)
38086 {setverdict(pass);} else {setverdict(fail);}
38091 Overall verdict: pass
38097 .*---------------------------------------------------------------------*
38098 :h3. DECODING , CER , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
38099 .*---------------------------------------------------------------------*
38102 <TC - DECODING , CER , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
38120 b [0] BOOLEAN OPTIONAL,
38121 c [1] INTEGER OPTIONAL
38129 import from TempA all;
38131 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38134 const BERPDU myValue := {b := true,
38140 if (dec_BER_PDU('A0808001FF8101050000'O) == myValue)
38144 {setverdict(pass);} else {setverdict(fail);}
38149 Overall verdict: pass
38155 .*---------------------------------------------------------------------*
38156 :h3. DECODING , reverse order, TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
38157 .*---------------------------------------------------------------------*
38160 <TC - DECODING , reverse order, TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
38178 b [0] BOOLEAN OPTIONAL,
38179 c [1] INTEGER OPTIONAL
38187 import from TempA all;
38189 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38192 const BERPDU myValue := {b := true,
38198 if (dec_BER_PDU('A0068101058001FF'O) == myValue)
38202 {setverdict(pass);} else {setverdict(fail);}
38207 Overall verdict: pass
38213 .*---------------------------------------------------------------------*
38214 :h3. DECODING , reverse order , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
38215 .*---------------------------------------------------------------------*
38218 <TC - DECODING , reverse order , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
38236 b [0] BOOLEAN OPTIONAL,
38237 c [1] INTEGER OPTIONAL
38245 import from TempA all;
38247 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38250 const BERPDU myValue := {b := true,
38256 if (dec_BER_PDU('A0808101058001FF0000'O) == myValue)
38260 {setverdict(pass);} else {setverdict(fail);}
38265 Overall verdict: pass
38271 .*---------------------------------------------------------------------*
38272 :h3. DECODING , DER , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
38273 .*---------------------------------------------------------------------*
38276 <TC - DECODING , DER , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
38294 b [0] BOOLEAN OPTIONAL,
38295 c [1] INTEGER OPTIONAL
38303 import from TempA all;
38305 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38308 const BERPDU myValue := {b := true,
38314 if (dec_BER_PDU('A0068001FF810105'O) == myValue)
38318 {setverdict(pass);} else {setverdict(fail);}
38323 Overall verdict: pass
38329 .*---------------------------------------------------------------------*
38330 :h3. DECODING , CER , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
38331 .*---------------------------------------------------------------------*
38334 <TC - DECODING , CER , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
38352 b [0] BOOLEAN OPTIONAL,
38353 c [1] INTEGER OPTIONAL
38361 import from TempA all;
38363 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38366 const BERPDU myValue := {b := true,
38372 if (dec_BER_PDU('A0808001FF8101050000'O) == myValue)
38376 {setverdict(pass);} else {setverdict(fail);}
38381 Overall verdict: pass
38387 .*---------------------------------------------------------------------*
38388 :h3. DECODING , reverse order , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
38389 .*---------------------------------------------------------------------*
38392 <TC - DECODING , reverse order , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
38410 b [0] BOOLEAN OPTIONAL,
38411 c [1] INTEGER OPTIONAL
38419 import from TempA all;
38421 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38424 const BERPDU myValue := {b := true,
38430 if (dec_BER_PDU('A0068101058001FF'O) == myValue)
38434 {setverdict(pass);} else {setverdict(fail);}
38439 Overall verdict: pass
38445 .*---------------------------------------------------------------------*
38446 :h3. DECODING , reverse order, TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
38447 .*---------------------------------------------------------------------*
38450 <TC - DECODING , reverse order, TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
38468 b [0] BOOLEAN OPTIONAL,
38469 c [1] INTEGER OPTIONAL
38477 import from TempA all;
38479 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38482 const BERPDU myValue := {b := true,
38488 if (dec_BER_PDU('A0808101058001FF0000'O) == myValue)
38492 {setverdict(pass);} else {setverdict(fail);}
38497 Overall verdict: pass
38503 .*---------------------------------------------------------------------*
38504 :h3. DECODING ,DER, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
38505 .*---------------------------------------------------------------------*
38508 <TC - DECODING ,DER, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
38526 b [5] BOOLEAN OPTIONAL,
38535 import from TempA all;
38537 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38540 const BERPDU myValue := {b := true,
38546 if (dec_BER_PDU('31060201058501FF'O) == myValue)
38550 {setverdict(pass);} else {setverdict(fail);}
38555 Overall verdict: pass
38561 .*---------------------------------------------------------------------*
38562 :h3. DECODING ,CER, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
38563 .*---------------------------------------------------------------------*
38566 <TC - DECODING ,CER, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
38584 b [5] BOOLEAN OPTIONAL,
38593 import from TempA all;
38595 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38598 const BERPDU myValue := {b := true,
38604 if (dec_BER_PDU('31800201058501FF0000'O) == myValue)
38608 {setverdict(pass);} else {setverdict(fail);}
38613 Overall verdict: pass
38619 .*---------------------------------------------------------------------*
38620 :h3. DECODING ,reverse order, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
38621 .*---------------------------------------------------------------------*
38624 <TC - DECODING ,reverse order, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
38642 b [5] BOOLEAN OPTIONAL,
38651 import from TempA all;
38653 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38656 const BERPDU myValue := {b := true,
38662 if (dec_BER_PDU('31068501FF020105'O) == myValue)
38666 {setverdict(pass);} else {setverdict(fail);}
38671 Overall verdict: pass
38677 .*---------------------------------------------------------------------*
38678 :h3. DECODING ,reverse order, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
38679 .*---------------------------------------------------------------------*
38682 <TC - DECODING ,reverse order, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
38700 b [5] BOOLEAN OPTIONAL,
38709 import from TempA all;
38711 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38714 const BERPDU myValue := {b := true,
38720 if (dec_BER_PDU('31808501FF0201050000'O) == myValue)
38724 {setverdict(pass);} else {setverdict(fail);}
38729 Overall verdict: pass
38735 .*---------------------------------------------------------------------*
38736 :h3. DECODING ,DER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
38737 .*---------------------------------------------------------------------*
38740 <TC - DECODING ,DER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
38756 {x INTEGER OPTIONAL,
38763 b BOOLEAN OPTIONAL,
38764 c INTEGER OPTIONAL,
38765 COMPONENTS OF MySeq
38773 import from TempA all;
38775 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38778 const BERPDU myValue := {b := true,
38787 if (dec_BER_PDU('310C8001FF8101058201068301FF'O) == myValue)
38791 {setverdict(pass);} else {setverdict(fail);}
38796 Overall verdict: pass
38802 .*---------------------------------------------------------------------*
38803 :h3. DECODING ,CER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
38804 .*---------------------------------------------------------------------*
38807 <TC - DECODING ,CER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
38824 {x INTEGER OPTIONAL,
38831 b BOOLEAN OPTIONAL,
38832 c INTEGER OPTIONAL,
38833 COMPONENTS OF MySeq
38841 import from TempA all;
38843 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38845 const BERPDU myValue := {b := true,
38855 if (dec_BER_PDU('31808001FF8101058201068301FF0000'O) == myValue){setverdict(pass);} else {setverdict(fail);}
38860 Overall verdict: pass
38866 .*---------------------------------------------------------------------*
38867 :h3. DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
38868 .*---------------------------------------------------------------------*
38871 <TC - DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
38887 {x INTEGER OPTIONAL,
38894 b BOOLEAN OPTIONAL,
38895 c INTEGER OPTIONAL,
38896 COMPONENTS OF MySeq
38904 import from TempA all;
38906 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38909 const BERPDU myValue := {b := true,
38918 if (dec_BER_PDU('310C8001FF8201068101058301FF'O) == myValue)
38922 {setverdict(pass);} else {setverdict(fail);}
38927 Overall verdict: pass
38933 .*---------------------------------------------------------------------*
38934 :h3. DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
38935 .*---------------------------------------------------------------------*
38938 <TC - DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
38955 {x INTEGER OPTIONAL,
38962 b BOOLEAN OPTIONAL,
38963 c INTEGER OPTIONAL,
38964 COMPONENTS OF MySeq
38972 import from TempA all;
38974 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38976 const BERPDU myValue := {b := true,
38986 if (dec_BER_PDU('31808001FF8201068101058301FF0000'O) == myValue)
38990 {setverdict(pass);} else {setverdict(fail);}
38995 Overall verdict: pass
39001 .*---------------------------------------------------------------------*
39002 :h3. DECODING ,DER, SET ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39003 .*---------------------------------------------------------------------*
39006 <TC - DECODING ,DER, SET ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39022 {x [0] INTEGER OPTIONAL,
39029 b BOOLEAN OPTIONAL,
39030 c INTEGER OPTIONAL,
39031 COMPONENTS OF MySeq
39040 import from TempA all;
39042 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39045 const BERPDU myValue := {b := true,
39054 if (dec_BER_PDU('310C8001FF8101058201068301FF'O) == myValue)
39058 {setverdict(pass);} else {setverdict(fail);}
39063 Overall verdict: pass
39069 .*---------------------------------------------------------------------*
39070 :h3. DECODING ,CER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
39071 .*---------------------------------------------------------------------*
39074 <TC - DECODING ,CER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
39091 {x [0] INTEGER OPTIONAL,
39098 b BOOLEAN OPTIONAL,
39099 c INTEGER OPTIONAL,
39100 COMPONENTS OF MySeq
39110 import from TempA all;
39112 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39115 const BERPDU myValue := {b := true,
39124 if (dec_BER_PDU('31808001FF8101058201068301FF0000'O) == myValue)
39128 {setverdict(pass);} else {setverdict(fail);}
39133 Overall verdict: pass
39139 .*---------------------------------------------------------------------*
39140 :h3. DECODING ,different order, SET ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39141 .*---------------------------------------------------------------------*
39144 <TC - DECODING ,different order, SET ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39160 {x [0] INTEGER OPTIONAL,
39167 b BOOLEAN OPTIONAL,
39168 c INTEGER OPTIONAL,
39169 COMPONENTS OF MySeq
39178 import from TempA all;
39180 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39183 const BERPDU myValue := {b := true,
39192 if (dec_BER_PDU('310C8301FF8001FF820106810105'O) == myValue)
39196 {setverdict(pass);} else {setverdict(fail);}
39201 Overall verdict: pass
39207 .*---------------------------------------------------------------------*
39208 :h3. DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
39209 .*---------------------------------------------------------------------*
39212 <TC - DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
39229 {x [0] INTEGER OPTIONAL,
39236 b BOOLEAN OPTIONAL,
39237 c INTEGER OPTIONAL,
39238 COMPONENTS OF MySeq
39248 import from TempA all;
39250 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39253 const BERPDU myValue := {b := true,
39262 if (dec_BER_PDU('31808301FF8101058201068001FF0000'O) == myValue)
39266 {setverdict(pass);} else {setverdict(fail);}
39271 Overall verdict: pass
39277 .*---------------------------------------------------------------------*
39278 :h3. DECODING ,DER, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39279 .*---------------------------------------------------------------------*
39282 <TC - DECODING ,DER, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39299 {x INTEGER OPTIONAL,
39306 b [0] BOOLEAN OPTIONAL,
39307 c BIT STRING OPTIONAL,
39308 COMPONENTS OF MySeq
39315 import from TempA all;
39317 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39321 const BERPDU myValue := {b := true,
39329 if (dec_BER_PDU('310D020106030207800401FF8001FF'O) == myValue)
39332 {setverdict(pass);} else {setverdict(fail);}
39337 Overall verdict: pass
39343 .*---------------------------------------------------------------------*
39344 :h3. DECODING ,CER, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39345 .*---------------------------------------------------------------------*
39348 <TC - DECODING ,CER, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39365 {x INTEGER OPTIONAL,
39372 b [0] BOOLEAN OPTIONAL,
39373 c BIT STRING OPTIONAL,
39374 COMPONENTS OF MySeq
39384 import from TempA all;
39386 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39389 const BERPDU myValue := {b := true,
39397 if (dec_BER_PDU('3180020106030207800401FF8001FF0000'O) == myValue)
39401 {setverdict(pass);} else {setverdict(fail);}
39406 Overall verdict: pass
39412 .*---------------------------------------------------------------------*
39413 :h3. DECODING ,different order, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39414 .*---------------------------------------------------------------------*
39417 <TC - DECODING ,different order, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39434 {x INTEGER OPTIONAL,
39441 b [0] BOOLEAN OPTIONAL,
39442 c BIT STRING OPTIONAL,
39443 COMPONENTS OF MySeq
39450 import from TempA all;
39452 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39456 const BERPDU myValue := {b := true,
39464 if (dec_BER_PDU('310D030207800201060401FF8001FF'O) == myValue)
39468 {setverdict(pass);} else {setverdict(fail);}
39473 Overall verdict: pass
39479 .*---------------------------------------------------------------------*
39480 :h3. DECODING ,different order, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39481 .*---------------------------------------------------------------------*
39484 <TC - DECODING ,different order, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39501 {x INTEGER OPTIONAL,
39508 b [0] BOOLEAN OPTIONAL,
39509 c BIT STRING OPTIONAL,
39510 COMPONENTS OF MySeq
39520 import from TempA all;
39522 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39525 const BERPDU myValue := {b := true,
39533 if (dec_BER_PDU('3180030207800201060401FF8001FF0000'O) == myValue)
39537 {setverdict(pass);} else {setverdict(fail);}
39542 Overall verdict: pass
39548 .*---------------------------------------------------------------------*
39549 :h3. DECODING ,DER, SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39550 .*---------------------------------------------------------------------*
39553 <TC - DECODING ,DER, SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39570 {x [1] INTEGER OPTIONAL,
39577 b [0] BOOLEAN OPTIONAL,
39578 c BIT STRING OPTIONAL,
39579 COMPONENTS OF MySeq
39586 import from TempA all;
39588 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39592 const BERPDU myValue := {b := true,
39601 if (dec_BER_PDU('310D030207800401FF8001FF810106'O) == myValue)
39605 {setverdict(pass);} else {setverdict(fail);}
39610 Overall verdict: pass
39616 .*---------------------------------------------------------------------*
39617 :h3. DECODING ,CER, SET, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39618 .*---------------------------------------------------------------------*
39621 <TC - DECODING ,CER, SET, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39638 {x [1] INTEGER OPTIONAL,
39645 b [0] BOOLEAN OPTIONAL,
39646 c BIT STRING OPTIONAL,
39647 COMPONENTS OF MySeq
39657 import from TempA all;
39659 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39662 const BERPDU myValue := {b := true,
39671 if (dec_BER_PDU('3180030207800401FF8001FF8101060000'O) == myValue)
39675 {setverdict(pass);} else {setverdict(fail);}
39680 Overall verdict: pass
39686 .*---------------------------------------------------------------------*
39687 :h3. DECODING ,different order, SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39688 .*---------------------------------------------------------------------*
39691 <TC - DECODING ,different order, SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39708 {x [1] INTEGER OPTIONAL,
39715 b [0] BOOLEAN OPTIONAL,
39716 c BIT STRING OPTIONAL,
39717 COMPONENTS OF MySeq
39724 import from TempA all;
39726 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39730 const BERPDU myValue := {b := true,
39739 if (dec_BER_PDU('310D8101060401FF8001FF03020780'O) == myValue)
39743 {setverdict(pass);} else {setverdict(fail);}
39748 Overall verdict: pass
39754 .*---------------------------------------------------------------------*
39755 :h3. DECODING ,different order, SET, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39756 .*---------------------------------------------------------------------*
39759 <TC - DECODING ,different order, SET, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39776 {x [1] INTEGER OPTIONAL,
39783 b [0] BOOLEAN OPTIONAL,
39784 c BIT STRING OPTIONAL,
39785 COMPONENTS OF MySeq
39795 import from TempA all;
39797 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39800 const BERPDU myValue := {b := true,
39809 if (dec_BER_PDU('31808001FF0401FF030207808101060000'O) == myValue)
39813 {setverdict(pass);} else {setverdict(fail);}
39818 Overall verdict: pass
39824 .*---------------------------------------------------------------------*
39825 :h3. DECODING ,DER, SET with CHOICE element, AUTOMATIC TAGS
39826 .*---------------------------------------------------------------------*
39829 <TC - DECODING ,DER, SET with CHOICE element, AUTOMATIC TAGS>
39864 import from TempA all;
39866 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39869 const BERPDU myValue := {b := {x := true},
39877 if (dec_BER_PDU('3108A0038001FF810104'O) == myValue)
39881 {setverdict(pass);} else {setverdict(fail);}
39886 Overall verdict: pass
39892 .*---------------------------------------------------------------------*
39893 :h3. DECODING ,CER, SET with CHOICE element, AUTOMATIC TAGS
39894 .*---------------------------------------------------------------------*
39897 <TC - DECODING ,CER, SET with CHOICE element, AUTOMATIC TAGS>
39930 import from TempA all;
39932 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39935 const BERPDU myValue := {b := {x := true},
39942 if (dec_BER_PDU('3180A0808001FF00008101040000'O) == myValue)
39946 {setverdict(pass);} else {setverdict(fail);}
39951 Overall verdict: pass
39957 .*---------------------------------------------------------------------*
39958 :h3. DECODING ,reverse order, SET with CHOICE element, AUTOMATIC TAGS
39959 .*---------------------------------------------------------------------*
39962 <TC - DECODING ,reverse order, SET with CHOICE element, AUTOMATIC TAGS>
39997 import from TempA all;
39999 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40002 const BERPDU myValue := {b := {x := true},
40010 if (dec_BER_PDU('3108810104A0038001FF'O) == myValue)
40014 {setverdict(pass);} else {setverdict(fail);}
40019 Overall verdict: pass
40025 .*---------------------------------------------------------------------*
40026 :h3. DECODING ,reverse order, SET with CHOICE element, AUTOMATIC TAGS
40027 .*---------------------------------------------------------------------*
40030 <TC - DECODING ,reverse order, SET with CHOICE element, AUTOMATIC TAGS>
40063 import from TempA all;
40065 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40068 const BERPDU myValue := {b := {x := true},
40075 if (dec_BER_PDU('3180810104A0808001FF00000000'O) == myValue)
40079 {setverdict(pass);} else {setverdict(fail);}
40084 Overall verdict: pass
40090 .*---------------------------------------------------------------------*
40091 :h3. DECODING ,DER, SET with CHOICE element,
40092 .*---------------------------------------------------------------------*
40095 <TC - DECODING ,DER, SET with CHOICE element, >
40128 import from TempA all;
40130 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40132 const BERPDU myValue := {b := {x := true},
40140 if (dec_BER_PDU('31060101FF020104'O) == myValue) {setverdict(pass);} else {setverdict(fail);}
40145 Overall verdict: pass
40151 .*---------------------------------------------------------------------*
40152 :h3. DECODING ,CER, SET with CHOICE element,
40153 .*---------------------------------------------------------------------*
40156 <TC - DECODING ,CER, SET with CHOICE element, >
40188 import from TempA all;
40190 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40193 const BERPDU myValue := {b := {x := true},
40200 if (dec_BER_PDU('31800101FF0201040000'O) == myValue){setverdict(pass);} else {setverdict(fail);}
40205 Overall verdict: pass
40211 .*---------------------------------------------------------------------*
40212 :h3. DECODING ,reverse order, SET with CHOICE element,
40213 .*---------------------------------------------------------------------*
40216 <TC - DECODING ,reverse order, SET with CHOICE element, >
40249 import from TempA all;
40251 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40253 const BERPDU myValue := {b := {x := true},
40261 if (dec_BER_PDU('31060201040101FF'O) == myValue)
40265 {setverdict(pass);} else {setverdict(fail);}
40270 Overall verdict: pass
40276 .*---------------------------------------------------------------------*
40277 :h3. DECODING ,reverse order, SET with CHOICE element,
40278 .*---------------------------------------------------------------------*
40281 <TC - DECODING ,reverse order, SET with CHOICE element, >
40313 import from TempA all;
40315 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40318 const BERPDU myValue := {b := {x := true},
40325 if (dec_BER_PDU('31800201040101FF0000'O) == myValue)
40329 {setverdict(pass);} else {setverdict(fail);}
40334 Overall verdict: pass
40340 .*---------------------------------------------------------------------*
40341 :h3. DECODING DER, SET with CHOICE element, different choice
40342 .*---------------------------------------------------------------------*
40345 <TC - DECODING DER, SET with CHOICE element, different choice >
40377 import from TempA all;
40379 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40382 const BERPDU myValue := {b := {y := 'FF'O},
40389 if (dec_BER_PDU('31060201040401FF'O) == myValue)
40393 {setverdict(pass);} else {setverdict(fail);}
40398 Overall verdict: pass
40404 .*---------------------------------------------------------------------*
40405 :h3. DECODING CER, SET with CHOICE element, different choice
40406 .*---------------------------------------------------------------------*
40409 <TC - DECODING CER, SET with CHOICE element, different choice >
40441 import from TempA all;
40443 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40446 const BERPDU myValue := {b := {y := 'FF'O},
40453 if (dec_BER_PDU('31800401FF0201040000'O) == myValue)
40457 {setverdict(pass);} else {setverdict(fail);}
40462 Overall verdict: pass
40468 .*---------------------------------------------------------------------*
40469 :h3. DECODING , SET with CHOICE element, different choice
40470 .*---------------------------------------------------------------------*
40473 <TC - DECODING , SET with CHOICE element, different choice >
40505 import from TempA all;
40507 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40510 const BERPDU myValue := {b := {y := 'FF'O},
40517 if (dec_BER_PDU('31060401FF020104'O) == myValue)
40521 {setverdict(pass);} else {setverdict(fail);}
40526 Overall verdict: pass
40532 .*---------------------------------------------------------------------*
40533 :h3. DECODING , SET with CHOICE element, different choice
40534 .*---------------------------------------------------------------------*
40537 <TC - DECODING , SET with CHOICE element, different choice >
40569 import from TempA all;
40571 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40574 const BERPDU myValue := {b := {y := 'FF'O},
40581 if (dec_BER_PDU('31800201040401FF0000'O) == myValue)
40585 {setverdict(pass);} else {setverdict(fail);}
40590 Overall verdict: pass
40596 .*---------------------------------------------------------------------*
40597 :h3. DECODING ,DER, SET with EXTENSION , AUTOMATIC TAGS
40598 .*---------------------------------------------------------------------*
40601 <TC - DECODING ,DER, SET with EXTENSION , AUTOMATIC TAGS>
40624 c INTEGER OPTIONAL,
40639 import from TempA all;
40641 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40644 const BERPDU myValue := {
40653 if (dec_BER_PDU('310D8001FF8101FF82010483020780'O) == myValue)
40657 {setverdict(pass);} else {setverdict(fail);}
40662 Overall verdict: pass
40668 .*---------------------------------------------------------------------*
40669 :h3. DECODING ,CER, SET with EXTENSION , AUTOMATIC TAGS
40670 .*---------------------------------------------------------------------*
40673 <TC - DECODING ,CER, SET with EXTENSION , AUTOMATIC TAGS>
40696 c INTEGER OPTIONAL,
40709 import from TempA all;
40711 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40714 const BERPDU myValue := {
40723 if (dec_BER_PDU('31808001FF8101FF820104830207800000'O) == myValue)
40727 {setverdict(pass);} else {setverdict(fail);}
40732 Overall verdict: pass
40738 .*---------------------------------------------------------------------*
40739 :h3. DECODING ,different order, SET with EXTENSION , AUTOMATIC TAGS
40740 .*---------------------------------------------------------------------*
40743 <TC - DECODING ,different order, SET with EXTENSION , AUTOMATIC TAGS>
40766 c INTEGER OPTIONAL,
40781 import from TempA all;
40783 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40786 const BERPDU myValue := {
40795 if (dec_BER_PDU('310D8001FF830207808101FF820104'O) == myValue)
40799 {setverdict(pass);} else {setverdict(fail);}
40804 Overall verdict: pass
40810 .*---------------------------------------------------------------------*
40811 :h3. DECODING ,different order, SET with EXTENSION , AUTOMATIC TAGS
40812 .*---------------------------------------------------------------------*
40815 <TC - DECODING ,different order, SET with EXTENSION , AUTOMATIC TAGS>
40838 c INTEGER OPTIONAL,
40851 import from TempA all;
40853 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40856 const BERPDU myValue := {
40865 if (dec_BER_PDU('31808001FF830207808101FF8201040000'O) == myValue)
40869 {setverdict(pass);} else {setverdict(fail);}
40874 Overall verdict: pass
40880 .*---------------------------------------------------------------------*
40881 :h3. DECODING SET with Long Form , AUTOMATIC TAGS
40882 .*---------------------------------------------------------------------*
40885 <TC - DECODING SET with Long Form , AUTOMATIC TAGS>
40908 c INTEGER OPTIONAL,
40923 import from TempA all;
40925 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40928 const BERPDU myValue := {
40937 if (dec_BER_PDU('318300000D8001FF8101FF82010483020780'O) == myValue)
40941 {setverdict(pass);} else {setverdict(fail);}
40946 Overall verdict: pass
40952 .*---------------------------------------------------------------------*
40953 :h3. DECODING, different order, SET with Long Form , AUTOMATIC TAGS
40954 .*---------------------------------------------------------------------*
40957 <TC - DECODING, different order, SET with Long Form , AUTOMATIC TAGS>
40980 c INTEGER OPTIONAL,
40995 import from TempA all;
40997 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41000 const BERPDU myValue := {
41009 if (dec_BER_PDU('318300000D8101FF820104830207808001FF'O) == myValue)
41013 {setverdict(pass);} else {setverdict(fail);}
41018 Overall verdict: pass
41024 .*---------------------------------------------------------------------*
41025 :h3. DECODING , DER, SET with fields of different types ,
41026 .*---------------------------------------------------------------------*
41029 <TC - DECODING , DER, SET with fields of different types ,>
41048 d ENUMERATED {first ,second ,third},
41053 h OBJECT IDENTIFIER,
41055 j CHOICE {x1 [1] BOOLEAN,
41056 y1 [2] OCTET STRING},
41058 k SEQUENCE{x2 NULL,
41061 l SET { x3 BIT STRING,
41064 m [3] SEQUENCE OF INTEGER,
41065 n [4] SET OF BOOLEAN
41069 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41076 import from TempA all;
41078 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41081 const BERPDU myValue := {a := NULL,
41090 j := {x1 := true } ,
41109 if (dec_BER_PDU('31450101FF020102030207800402FFFF050006030002030A01001603414243300505000101FF3106030207800500A1030101FFA3083006020101020102A40831060101FF0101FF'O) == myValue)
41113 {setverdict(pass);} else {setverdict(fail);}
41118 Overall verdict: pass
41124 .*---------------------------------------------------------------------*
41125 :h3. DECODING , CER, SET with fields of different types ,
41126 .*---------------------------------------------------------------------*
41129 <TC - DECODING , CER, SET with fields of different types ,>
41148 d ENUMERATED {first ,second ,third},
41153 h OBJECT IDENTIFIER,
41155 j CHOICE {x1 [1] BOOLEAN,
41156 y1 [2] OCTET STRING},
41158 k SEQUENCE{x2 NULL,
41161 l SET { x3 BIT STRING,
41164 m [3] SEQUENCE OF INTEGER,
41165 n [4] SET OF BOOLEAN
41169 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41176 import from TempA all;
41178 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41181 const BERPDU myValue := {a := NULL,
41185 // e := 1.0, 090603312E452B30
41190 j := {x1 := true } ,
41209 if (dec_BER_PDU('31800101FF020102030207800402FFFF050006030002030A01001603414243308005000101FF000031800302078005000000A1800101FF0000A380308002010102010200000000A48031800101FF0101FF000000000000'O) == myValue)
41213 {setverdict(pass);} else {setverdict(fail);}
41218 Overall verdict: pass
41224 .*---------------------------------------------------------------------*
41225 :h3. DECODING , different order, SET with fields of different types , different order
41226 .*---------------------------------------------------------------------*
41229 <TC - DECODING , different order, SET with fields of different types , different order >
41248 d ENUMERATED {first ,second ,third},
41253 h OBJECT IDENTIFIER,
41255 j CHOICE {x1 [1] BOOLEAN,
41256 y1 [2] OCTET STRING},
41258 k SEQUENCE{x2 NULL,
41261 l SET { x3 BIT STRING,
41264 m [3] SEQUENCE OF INTEGER,
41265 n [4] SET OF BOOLEAN
41269 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41276 import from TempA all;
41278 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41281 const BERPDU myValue := {a := NULL,
41290 j := {x1 := true } ,
41309 if (dec_BER_PDU('31450101FF0201020A0100030207800402FFFF06030002031603414243A1030101FF300505000101FF3106030207800500A3083006020101020102A40831060101FF0101FF0500'O) == myValue)
41313 {setverdict(pass);} else {setverdict(fail);}
41318 Overall verdict: pass
41324 .*---------------------------------------------------------------------*
41325 :h3. DECODING , different order, SET with fields of different types , different order2
41326 .*---------------------------------------------------------------------*
41329 <TC - DECODING , different order, SET with fields of different types , different order2>
41348 d ENUMERATED {first ,second ,third},
41353 h OBJECT IDENTIFIER,
41355 j CHOICE {x1 [1] BOOLEAN,
41356 y1 [2] OCTET STRING},
41358 k SEQUENCE{x2 NULL,
41361 l SET { x3 BIT STRING,
41364 m [3] SEQUENCE OF INTEGER,
41365 n [4] SET OF BOOLEAN
41369 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41376 import from TempA all;
41378 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41381 const BERPDU myValue := {a := NULL,
41385 // e := 1.0, 090603312E452B30
41390 j := {x1 := true } ,
41409 if (dec_BER_PDU('31800101FF0201020A0100030207800402FFFF050006030002031603414243A1800101FF0000308005000101FF000031800302078005000000A380308002010102010200000000A48031800101FF0101FF000000000000'O) == myValue)
41413 {setverdict(pass);} else {setverdict(fail);}
41418 Overall verdict: pass
41424 .*---------------------------------------------------------------------*
41425 :h3. DECODING , DER, SET with fields of different types , AUTOMATIC TAGS
41426 .*---------------------------------------------------------------------*
41429 <TC - DECODING , DER, SET with fields of different types , AUTOMATIC TAGS>
41449 d ENUMERATED {first ,second ,third},
41454 h OBJECT IDENTIFIER,
41456 j CHOICE {x1 BOOLEAN,
41459 k SEQUENCE{x2 NULL,
41462 l SET { x3 BIT STRING,
41465 m SEQUENCE OF INTEGER,
41468 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41475 import from TempA all;
41477 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41480 const BERPDU myValue := {a := NULL,
41489 j := {x1 := true } ,
41509 if (dec_BER_PDU('314380008101FF8201028301008400850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB06800207808100AC06020101020102AD060101FF0101FF'O) == myValue)
41513 {setverdict(pass);} else {setverdict(fail);}
41518 Overall verdict: pass
41524 .*---------------------------------------------------------------------*
41525 :h3. DECODING , DER, SET with fields of different types ,AUTOMATIC TAGS
41526 .*---------------------------------------------------------------------*
41529 <TC - DECODING , DER, SET with fields of different types ,AUTOMATIC TAGS>
41548 d ENUMERATED {first ,second ,third},
41553 h OBJECT IDENTIFIER,
41555 j CHOICE {x1 BOOLEAN,
41558 k SEQUENCE{x2 NULL,
41561 l SET { x3 BIT STRING,
41564 m SEQUENCE OF INTEGER,
41567 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41575 import from TempA all;
41577 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41580 const BERPDU myValue := {a := NULL,
41589 j := {x1 := true } ,
41609 if (dec_BER_PDU('318080008101FF8201028301008400850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB808002078081000000AC800201010201020000AD800101FF0101FF00000000'O) == myValue)
41613 {setverdict(pass);} else {setverdict(fail);}
41618 Overall verdict: pass
41624 .*---------------------------------------------------------------------*
41625 :h3. DECODING , different order, SET with fields of different types , AUTOMATIC TAGS
41626 .*---------------------------------------------------------------------*
41629 <TC - DECODING , different order, SET with fields of different types , AUTOMATIC TAGS>
41649 d ENUMERATED {first ,second ,third},
41654 h OBJECT IDENTIFIER,
41656 j CHOICE {x1 BOOLEAN,
41659 k SEQUENCE{x2 NULL,
41662 l SET { x3 BIT STRING,
41665 m SEQUENCE OF INTEGER,
41668 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41675 import from TempA all;
41677 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41680 const BERPDU myValue := {a := NULL,
41689 j := {x1 := true } ,
41709 if (dec_BER_PDU('31438101FF8201028301008400850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB06800207808100AC06020101020102AD060101FF0101FF8000'O) == myValue)
41713 {setverdict(pass);} else {setverdict(fail);}
41718 Overall verdict: pass
41724 .*---------------------------------------------------------------------*
41725 :h3. DECODING , different order, SET with fields of different types ,AUTOMATIC TAGS
41726 .*---------------------------------------------------------------------*
41729 <TC - DECODING , different order, SET with fields of different types ,AUTOMATIC TAGS>
41748 d ENUMERATED {first ,second ,third},
41753 h OBJECT IDENTIFIER,
41755 j CHOICE {x1 BOOLEAN,
41758 k SEQUENCE{x2 NULL,
41761 l SET { x3 BIT STRING,
41764 m SEQUENCE OF INTEGER,
41767 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41775 import from TempA all;
41777 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41780 const BERPDU myValue := {a := NULL,
41789 j := {x1 := true } ,
41809 if (dec_BER_PDU('318080008201028101FF8301008400850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB808002078081000000AC800201010201020000AD800101FF0101FF00000000'O) == myValue)
41813 {setverdict(pass);} else {setverdict(fail);}
41818 Overall verdict: pass
41824 .*---------------------------------------------------------------------*
41825 :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGS
41826 .*---------------------------------------------------------------------*
41829 <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGS>
41846 d [PRIVATE 0] INTEGER OPTIONAL,
41847 a INTEGER OPTIONAL,
41848 b [APPLICATION 0] INTEGER OPTIONAL,
41849 c [0] INTEGER OPTIONAL
41859 import from TempA all;
41861 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41864 const BERPDU myValue := {
41874 if (dec_BER_PDU('310C020101400102800103C00104'O) == myValue)
41876 {setverdict(pass);} else {setverdict(fail);}
41881 Overall verdict: pass
41887 .*---------------------------------------------------------------------*
41888 :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGS
41889 .*---------------------------------------------------------------------*
41892 <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGS>
41909 d [PRIVATE 0] INTEGER OPTIONAL,
41910 a INTEGER OPTIONAL,
41911 b [APPLICATION 0] INTEGER OPTIONAL,
41912 c [0] INTEGER OPTIONAL
41922 import from TempA all;
41924 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41927 const BERPDU myValue := {
41937 if (dec_BER_PDU('3180020101400102800103C001040000'O) == myValue)
41939 {setverdict(pass);} else {setverdict(fail);}
41944 Overall verdict: pass
41950 .*---------------------------------------------------------------------*
41951 :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )
41952 .*---------------------------------------------------------------------*
41955 <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )>
41968 d [PRIVATE 0] INTEGER OPTIONAL,
41969 a INTEGER OPTIONAL,
41970 b [APPLICATION 0] INTEGER OPTIONAL,
41971 c [0] INTEGER OPTIONAL
41981 import from TempA all;
41983 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41986 const BERPDU myValue := {
41996 if (dec_BER_PDU('31120201016003020102A003020103E003020104'O) == myValue)
41998 {setverdict(pass);} else {setverdict(fail);}
42003 Overall verdict: pass
42009 .*---------------------------------------------------------------------*
42010 :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )
42011 .*---------------------------------------------------------------------*
42014 <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )>
42027 d [PRIVATE 0] INTEGER OPTIONAL,
42028 a INTEGER OPTIONAL,
42029 b [APPLICATION 0] INTEGER OPTIONAL,
42030 c [0] INTEGER OPTIONAL
42040 import from TempA all;
42042 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
42045 const BERPDU myValue := {
42055 if (dec_BER_PDU('318002010160800201020000A0800201030000E08002010400000000'O) == myValue)
42057 {setverdict(pass);} else {setverdict(fail);}
42062 Overall verdict: pass
42068 .*---------------------------------------------------------------------*
42069 :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGS
42070 .*---------------------------------------------------------------------*
42073 <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGS>
42092 d [PRIVATE 0] INTEGER OPTIONAL,
42093 a INTEGER OPTIONAL,
42094 b [APPLICATION 0] INTEGER OPTIONAL,
42095 c [0] INTEGER OPTIONAL
42105 import from TempA all;
42107 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
42110 const BERPDU myValue := {
42120 if (dec_BER_PDU('31120201016003020102A003020103E003020104'O) == myValue)
42122 {setverdict(pass);} else {setverdict(fail);}
42127 Overall verdict: pass
42133 .*---------------------------------------------------------------------*
42134 :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGGING
42135 .*---------------------------------------------------------------------*
42138 <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGGING>
42156 d [PRIVATE 0] INTEGER OPTIONAL,
42157 a INTEGER OPTIONAL,
42158 b [APPLICATION 0] INTEGER OPTIONAL,
42159 c [0] INTEGER OPTIONAL
42169 import from TempA all;
42171 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
42174 const BERPDU myValue := {
42184 if (dec_BER_PDU('318002010160800201020000A0800201030000E08002010400000000'O) == myValue)
42186 {setverdict(pass);} else {setverdict(fail);}
42191 Overall verdict: pass
42197 .*---------------------------------------------------------------------*
42198 :h3. DECODING SET, DER, untagged CHOICE in SET
42199 .*---------------------------------------------------------------------*
42202 <TC - DECODING SET, DER, untagged CHOICE in SET>
42251 import from TempA all;
42253 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
42258 const BERPDU myValue := {
42261 e := { f := {g := 3 }}
42268 if (dec_BER_PDU('310BA103820102830101850103'O) == myValue)
42270 {setverdict(pass);} else {setverdict(fail);}
42275 Overall verdict: pass
42281 .*---------------------------------------------------------------------*
42282 :h3. DECODING SET, CER, untagged CHOICE in SET
42283 .*---------------------------------------------------------------------*
42286 <TC - DECODING SET, CER, untagged CHOICE in SET>
42335 import from TempA all;
42337 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
42342 const BERPDU myValue := {
42345 e := { f := {g := 3 }}
42352 if (dec_BER_PDU('3180850103A18082010200008301010000'O) == myValue)
42354 {setverdict(pass);} else {setverdict(fail);}
42359 Overall verdict: pass
42365 .*---------------------------------------------------------------------*
42366 :h3. DECODING SET, DER, untagged CHOICE in SET, EXPLICIT TAGS
42367 .*---------------------------------------------------------------------*
42370 <TC - DECODING SET, DER, untagged CHOICE in SET, EXPLICIT TAGS>
42419 import from TempA all;
42421 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
42426 const BERPDU myValue := {
42429 e := { f := {g := 3 }}
42436 if (dec_BER_PDU('3111A105A203020102A303020101A503020103'O) == myValue)
42438 {setverdict(pass);} else {setverdict(fail);}
42443 Overall verdict: pass
42449 .*---------------------------------------------------------------------*
42450 :h3. DECODING SET, CER, untagged CHOICE in SET, EXPLICIT TAGS
42451 .*---------------------------------------------------------------------*
42454 <TC - DECODING SET, CER, untagged CHOICE in SET, EXPLICIT TAGS>
42503 import from TempA all;
42505 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
42510 const BERPDU myValue := {
42513 e := { f := {g := 3 }}
42520 if (dec_BER_PDU('3180A5800201030000A180A28002010200000000A38002010100000000'O) == myValue)
42522 {setverdict(pass);} else {setverdict(fail);}
42527 Overall verdict: pass
42533 .*---------------------------------------------------------------------*
42534 :h3.CER + DER encoding of SET OF INTEGER (empty)
42535 .*---------------------------------------------------------------------*
42538 <TC - CER + DER encoding of SET OF INTEGER (empty)>
42547 BERPDU ::= SET OF INTEGER
42555 import from TempA all;
42556 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42557 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42559 const BERPDU myValue := { }
42566 if ((enc_DER_PDU(myValue) == '3100'O)and(enc_CER_PDU(myValue) == '31800000'O)) {setverdict(pass);} else {setverdict(fail);}
42570 Overall verdict: pass
42576 .*---------------------------------------------------------------------*
42577 :h3.CER + DER encoding of SET OF BOOLEAN
42578 .*---------------------------------------------------------------------*
42581 <TC - CER + DER encoding of SET OF BOOLEAN>
42590 BERPDU ::= SET OF BOOLEAN
42598 import from TempA all;
42599 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42600 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42602 const BERPDU myValue := {true, false }
42609 if ((enc_DER_PDU(myValue) == '31060101000101FF'O)and(enc_CER_PDU(myValue) == '31800101000101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
42613 Overall verdict: pass
42619 .*---------------------------------------------------------------------*
42620 :h3.CER + DER encoding of SET OF OCTET STRING
42621 .*---------------------------------------------------------------------*
42624 <TC - CER + DER encoding of SET OF OCTET STRING >
42633 BERPDU ::= SET OF OCTET STRING
42639 import from TempA all;
42640 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42641 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42643 const BERPDU myValue := {'FFFF'O, 'AB'O };
42647 if ((enc_DER_PDU(myValue) == '31070401AB0402FFFF'O)and(enc_CER_PDU(myValue) == '31800401AB0402FFFF0000'O)) {setverdict(pass);} else {setverdict(fail);}
42651 Overall verdict: pass
42657 .*---------------------------------------------------------------------*
42658 :h3.CER + DER encoding of SET OF SEQUENCE
42659 .*---------------------------------------------------------------------*
42662 <TC - CER + DER encoding of SET OF SEQUENCE >
42671 BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN}
42677 import from TempA all;
42678 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42679 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42681 const BERPDU myValue := {
42696 if ((enc_DER_PDU(myValue) == '3110300602010301010030060201050101FF'O)and(enc_CER_PDU(myValue) == '31803080020103010100000030800201050101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
42700 Overall verdict: pass
42706 .*---------------------------------------------------------------------*
42707 :h3.CER + DER encoding of SET OF SET
42708 .*---------------------------------------------------------------------*
42711 <TC - CER + DER encoding of SET OF SET >
42720 BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN}
42726 import from TempA all;
42727 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42728 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42730 const BERPDU myValue := {
42745 if ((enc_DER_PDU(myValue) == '3110310601010002010331060101FF020105'O)and(enc_CER_PDU(myValue) == '31803180010100020103000031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
42749 Overall verdict: pass
42755 .*---------------------------------------------------------------------*
42756 :h3.CER + DER encoding of SET OF CHOICE
42757 .*---------------------------------------------------------------------*
42760 <TC - CER + DER encoding of SET OF CHOICE >
42769 BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN}
42775 import from TempA all;
42776 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42777 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42779 const BERPDU myValue := {
42792 if ((enc_DER_PDU(myValue) == '3106010100020105'O)and(enc_CER_PDU(myValue) == '31800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);}
42796 Overall verdict: pass
42802 .*---------------------------------------------------------------------*
42803 :h3.CER + DER encoding of SET OF SEQUENCE OF
42804 .*---------------------------------------------------------------------*
42807 <TC - CER + DER encoding of SET OF SEQUENCE OF>
42816 BERPDU ::= SET OF SEQUENCE OF INTEGER
42822 import from TempA all;
42823 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42824 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42826 const BERPDU myValue := {
42842 if ((enc_DER_PDU(myValue) == '311630090201010201020201033009020105020106020107'O)and(enc_CER_PDU(myValue) == '318030800201010201020201030000308002010502010602010700000000'O)) {setverdict(pass);} else {setverdict(fail);}
42846 Overall verdict: pass
42852 .*---------------------------------------------------------------------*
42853 :h3.CER + DER encoding of SET OF SET OF
42854 .*---------------------------------------------------------------------*
42857 <TC - CER + DER encoding of SET OF SET OF>
42866 BERPDU ::= SET OF SET OF INTEGER
42872 import from TempA all;
42873 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42874 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42876 const BERPDU myValue := {
42892 if ((enc_DER_PDU(myValue) == '311631090201010201020201033109020105020106020107'O)and(enc_CER_PDU(myValue) == '318031800201010201020201030000318002010502010602010700000000'O)) {setverdict(pass);} else {setverdict(fail);}
42896 Overall verdict: pass
42902 .*---------------------------------------------------------------------*
42903 :h3.CER + DER encoding of TAGGED SET OF BOOLEAN
42904 .*---------------------------------------------------------------------*
42907 <TC - CER + DER encoding of TAGGED SET OF BOOLEAN>
42916 BERPDU ::= [0] SET OF BOOLEAN
42924 import from TempA all;
42925 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42926 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42928 const BERPDU myValue := {true, false }
42935 if ((enc_DER_PDU(myValue) == 'A00831060101000101FF'O)and(enc_CER_PDU(myValue) == 'A08031800101000101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
42939 Overall verdict: pass
42945 .*---------------------------------------------------------------------*
42946 :h3.CER + DER encoding of TAGGED SET OF BOOLEAN, EXPLICIT TAGGING
42947 .*---------------------------------------------------------------------*
42950 <TC - CER + DER encoding of TAGGED SET OF BOOLEAN, EXPLICIT TAGGING>
42964 BERPDU ::= [0] SET OF BOOLEAN
42972 import from TempA all;
42973 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42974 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42976 const BERPDU myValue := {true, false }
42983 if ((enc_DER_PDU(myValue) == 'A00831060101000101FF'O)and(enc_CER_PDU(myValue) == 'A08031800101000101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
42987 Overall verdict: pass
42993 .*---------------------------------------------------------------------*
42994 :h3.CER + DER encoding of TAGGED SET OF BOOLEAN, IMPLICIT TAGGING
42995 .*---------------------------------------------------------------------*
42998 <TC - CER + DER encoding of TAGGED SET OF BOOLEAN, IMPLICIT TAGGING>
43012 BERPDU ::= [0] SET OF BOOLEAN
43020 import from TempA all;
43021 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
43022 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
43024 const BERPDU myValue := {true, false }
43031 if ((enc_DER_PDU(myValue) == 'A0060101000101FF'O)and(enc_CER_PDU(myValue) == 'A0800101000101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
43035 Overall verdict: pass
43041 .*---------------------------------------------------------------------*
43042 :h3.CER + DER encoding of SET OF OCTET STRING
43043 .*---------------------------------------------------------------------*
43046 <TC - CER + DER encoding of SET OF OCTET STRING >
43055 BERPDU ::= SET OF OCTET STRING
43061 import from TempA all;
43062 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
43063 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
43065 const BERPDU myValue := {'FFFF'O, ''O };
43069 if ((enc_DER_PDU(myValue) == '310604000402FFFF'O)and(enc_CER_PDU(myValue) == '318004000402FFFF0000'O)) {setverdict(pass);} else {setverdict(fail);}
43073 Overall verdict: pass
43079 .*---------------------------------------------------------------------*
43080 :h3. DECODING DER, SET OF INTEGER (empty)
43081 .*---------------------------------------------------------------------*
43084 <TC - DECODING DER, SET OF INTEGER (empty)>
43093 BERPDU ::= SET OF INTEGER
43099 import from TempA all;
43101 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43103 const BERPDU myValue := { }
43108 if (dec_BER_PDU('3100'O) == myValue)
43110 {setverdict(pass);} else {setverdict(fail);}
43115 Overall verdict: pass
43121 .*---------------------------------------------------------------------*
43122 :h3. DECODING CER, SET OF INTEGER (empty)
43123 .*---------------------------------------------------------------------*
43126 <TC - DECODING CER, SET OF INTEGER (empty)>
43135 BERPDU ::= SET OF INTEGER
43141 import from TempA all;
43143 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43145 const BERPDU myValue := { }
43150 if (dec_BER_PDU('31800000'O) == myValue)
43152 {setverdict(pass);} else {setverdict(fail);}
43157 Overall verdict: pass
43163 .*---------------------------------------------------------------------*
43164 :h3. DECODING DER, SET OF BOOLEAN
43165 .*---------------------------------------------------------------------*
43168 <TC - DECODING DER, SET OF BOOLEAN>
43177 BERPDU ::= SET OF BOOLEAN
43183 import from TempA all;
43185 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43187 const BERPDU myValue := {true, false }
43192 if (dec_BER_PDU('31060101000101FF'O) == myValue)
43194 {setverdict(pass);} else {setverdict(fail);}
43199 Overall verdict: pass
43205 .*---------------------------------------------------------------------*
43206 :h3. DECODING CER, SET OF BOOLEAN
43207 .*---------------------------------------------------------------------*
43210 <TC - DECODING CER, SET OF BOOLEAN>
43219 BERPDU ::= SET OF BOOLEAN
43225 import from TempA all;
43227 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43229 const BERPDU myValue := {true, false }
43234 if (dec_BER_PDU('31800101000101FF0000'O) == myValue)
43236 {setverdict(pass);} else {setverdict(fail);}
43241 Overall verdict: pass
43247 .*---------------------------------------------------------------------*
43248 :h3. DECODING , SET OF BOOLEAN (different order)
43249 .*---------------------------------------------------------------------*
43252 <TC - DECODING , SET OF BOOLEAN (different order)>
43261 BERPDU ::= SET OF BOOLEAN
43267 import from TempA all;
43269 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43271 const BERPDU myValue := {true, false }
43276 if (dec_BER_PDU('31060101FF010100'O) == myValue)
43278 {setverdict(pass);} else {setverdict(fail);}
43283 Overall verdict: pass
43289 .*---------------------------------------------------------------------*
43290 :h3. DECODING , SET OF BOOLEAN (different order2)
43291 .*---------------------------------------------------------------------*
43294 <TC - DECODING , SET OF BOOLEAN (different order2)>
43303 BERPDU ::= SET OF BOOLEAN
43309 import from TempA all;
43311 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43313 const BERPDU myValue := {true, false }
43318 if (dec_BER_PDU('31800101FF0101000000'O) == myValue)
43320 {setverdict(pass);} else {setverdict(fail);}
43325 Overall verdict: pass
43331 .*---------------------------------------------------------------------*
43332 :h3. DECODING DER,SET OF OCTET STRING
43333 .*---------------------------------------------------------------------*
43336 <TC - DECODING DER,SET OF OCTET STRING >
43345 BERPDU ::= SET OF OCTET STRING
43351 import from TempA all;
43353 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43355 const BERPDU myValue := {'FFFF'O, 'AB'O };
43360 if (dec_BER_PDU('31070401AB0402FFFF'O) == myValue)
43362 {setverdict(pass);} else {setverdict(fail);}
43367 Overall verdict: pass
43373 .*---------------------------------------------------------------------*
43374 :h3. DECODING CER,SET OF OCTET STRING
43375 .*---------------------------------------------------------------------*
43378 <TC - DECODING CER,SET OF OCTET STRING >
43387 BERPDU ::= SET OF OCTET STRING
43393 import from TempA all;
43395 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43397 const BERPDU myValue := {'FFFF'O, 'AB'O };
43402 if (dec_BER_PDU('31800401AB0402FFFF0000'O) == myValue)
43404 {setverdict(pass);} else {setverdict(fail);}
43409 Overall verdict: pass
43415 .*---------------------------------------------------------------------*
43416 :h3. DECODING ,SET OF OCTET STRING (different order)
43417 .*---------------------------------------------------------------------*
43420 <TC - DECODING ,SET OF OCTET STRING (different order)>
43429 BERPDU ::= SET OF OCTET STRING
43435 import from TempA all;
43437 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43439 const BERPDU myValue := {'FFFF'O, 'AB'O };
43444 if (dec_BER_PDU('31070402FFFF0401AB'O) == myValue)
43446 {setverdict(pass);} else {setverdict(fail);}
43451 Overall verdict: pass
43457 .*---------------------------------------------------------------------*
43458 :h3. DECODING ,SET OF OCTET STRING (different order)
43459 .*---------------------------------------------------------------------*
43462 <TC - DECODING ,SET OF OCTET STRING (different order)>
43471 BERPDU ::= SET OF OCTET STRING
43477 import from TempA all;
43479 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43481 const BERPDU myValue := {'FFFF'O, 'AB'O };
43486 if (dec_BER_PDU('31800402FFFF0401AB0000'O) == myValue)
43488 {setverdict(pass);} else {setverdict(fail);}
43493 Overall verdict: pass
43499 .*---------------------------------------------------------------------*
43500 :h3. DECODING DER,SET OF SEQUENCE
43501 .*---------------------------------------------------------------------*
43504 <TC - DECODING DER,SET OF SEQUENCE >
43513 BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN}
43519 import from TempA all;
43521 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43523 const BERPDU myValue := {
43539 if (dec_BER_PDU('3110300602010301010030060201050101FF'O) == myValue)
43541 {setverdict(pass);} else {setverdict(fail);}
43546 Overall verdict: pass
43552 .*---------------------------------------------------------------------*
43553 :h3. DECODING CER,SET OF SEQUENCE
43554 .*---------------------------------------------------------------------*
43557 <TC - DECODING CER,SET OF SEQUENCE >
43566 BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN}
43572 import from TempA all;
43574 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43576 const BERPDU myValue := {
43592 if (dec_BER_PDU('31803080020103010100000030800201050101FF00000000'O) == myValue)
43594 {setverdict(pass);} else {setverdict(fail);}
43599 Overall verdict: pass
43605 .*---------------------------------------------------------------------*
43606 :h3. DECODING ,SET OF SEQUENCE (different order)
43607 .*---------------------------------------------------------------------*
43610 <TC - DECODING ,SET OF SEQUENCE (different order)>
43619 BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN}
43625 import from TempA all;
43627 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43629 const BERPDU myValue := {
43645 if (dec_BER_PDU('311030060201050101FF3006020103010100'O) == myValue)
43647 {setverdict(pass);} else {setverdict(fail);}
43652 Overall verdict: pass
43658 .*---------------------------------------------------------------------*
43659 :h3. DECODING ,SET OF SEQUENCE (different order2)
43660 .*---------------------------------------------------------------------*
43663 <TC - DECODING ,SET OF SEQUENCE (different order2)>
43672 BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN}
43678 import from TempA all;
43680 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43682 const BERPDU myValue := {
43698 if (dec_BER_PDU('318030800201050101FF0000308002010301010000000000'O) == myValue)
43700 {setverdict(pass);} else {setverdict(fail);}
43705 Overall verdict: pass
43711 .*---------------------------------------------------------------------*
43712 :h3. DECODING DER,SET OF SET
43713 .*---------------------------------------------------------------------*
43716 <TC - DECODING DER,SET OF SET >
43725 BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN}
43731 import from TempA all;
43733 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43735 const BERPDU myValue := {
43751 if (dec_BER_PDU('3110310601010002010331060101FF020105'O) == myValue)
43753 {setverdict(pass);} else {setverdict(fail);}
43758 Overall verdict: pass
43764 .*---------------------------------------------------------------------*
43765 :h3. DECODING CER,SET OF SET
43766 .*---------------------------------------------------------------------*
43769 <TC - DECODING CER,SET OF SET >
43778 BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN}
43784 import from TempA all;
43786 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43788 const BERPDU myValue := {
43804 if (dec_BER_PDU('31803180010100020103000031800101FF02010500000000'O) == myValue)
43806 {setverdict(pass);} else {setverdict(fail);}
43811 Overall verdict: pass
43817 .*---------------------------------------------------------------------*
43818 :h3. DECODING ,SET OF SET (different order)
43819 .*---------------------------------------------------------------------*
43822 <TC - DECODING ,SET OF SET (different order)>
43831 BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN}
43837 import from TempA all;
43839 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43841 const BERPDU myValue := {
43857 if (dec_BER_PDU('311031060101FF0201053106010100020103'O) == myValue)
43859 {setverdict(pass);} else {setverdict(fail);}
43864 Overall verdict: pass
43870 .*---------------------------------------------------------------------*
43871 :h3. DECODING ,SET OF SET (different order2)
43872 .*---------------------------------------------------------------------*
43875 <TC - DECODING ,SET OF SET (different order2)>
43884 BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN}
43890 import from TempA all;
43892 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43894 const BERPDU myValue := {
43910 if (dec_BER_PDU('318031800101FF0201050000318001010002010300000000'O) == myValue)
43912 {setverdict(pass);} else {setverdict(fail);}
43917 Overall verdict: pass
43923 .*---------------------------------------------------------------------*
43924 :h3. DECODING DER,SET OF CHOICE
43925 .*---------------------------------------------------------------------*
43928 <TC - DECODING DER,SET OF CHOICE >
43937 BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN}
43943 import from TempA all;
43945 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43947 const BERPDU myValue := {
43961 if (dec_BER_PDU('3106010100020105'O) == myValue)
43963 {setverdict(pass);} else {setverdict(fail);}
43968 Overall verdict: pass
43974 .*---------------------------------------------------------------------*
43975 :h3. DECODING CER,SET OF CHOICE
43976 .*---------------------------------------------------------------------*
43979 <TC - DECODING CER,SET OF CHOICE >
43988 BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN}
43994 import from TempA all;
43996 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43998 const BERPDU myValue := {
44012 if (dec_BER_PDU('31800101000201050000'O) == myValue)
44014 {setverdict(pass);} else {setverdict(fail);}
44019 Overall verdict: pass
44025 .*---------------------------------------------------------------------*
44026 :h3. DECODING ,SET OF CHOICE (different order)
44027 .*---------------------------------------------------------------------*
44030 <TC - DECODING ,SET OF CHOICE (different order)>
44039 BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN}
44045 import from TempA all;
44047 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44049 const BERPDU myValue := {
44063 if (dec_BER_PDU('3106020105010100'O) == myValue)
44065 {setverdict(pass);} else {setverdict(fail);}
44070 Overall verdict: pass
44076 .*---------------------------------------------------------------------*
44077 :h3. DECODING ,SET OF CHOICE (different order2)
44078 .*---------------------------------------------------------------------*
44081 <TC - DECODING ,SET OF CHOICE (different order2)>
44090 BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN}
44096 import from TempA all;
44098 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44100 const BERPDU myValue := {
44114 if (dec_BER_PDU('31800201050101000000'O) == myValue)
44116 {setverdict(pass);} else {setverdict(fail);}
44121 Overall verdict: pass
44127 .*---------------------------------------------------------------------*
44128 :h3. DECODING DER,SET OF SEQUENCE OF
44129 .*---------------------------------------------------------------------*
44132 <TC - DECODING DER,SET OF SEQUENCE OF>
44141 BERPDU ::= SET OF SEQUENCE OF INTEGER
44147 import from TempA all;
44149 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44151 const BERPDU myValue := {
44168 if (dec_BER_PDU('311630090201010201020201033009020105020106020107'O) == myValue)
44170 {setverdict(pass);} else {setverdict(fail);}
44175 Overall verdict: pass
44181 .*---------------------------------------------------------------------*
44182 :h3. DECODING CER,SET OF SEQUENCE OF
44183 .*---------------------------------------------------------------------*
44186 <TC - DECODING CER,SET OF SEQUENCE OF>
44195 BERPDU ::= SET OF SEQUENCE OF INTEGER
44201 import from TempA all;
44203 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44205 const BERPDU myValue := {
44222 if (dec_BER_PDU('318030800201010201020201030000308002010502010602010700000000'O) == myValue)
44224 {setverdict(pass);} else {setverdict(fail);}
44229 Overall verdict: pass
44235 .*---------------------------------------------------------------------*
44236 :h3. DECODING ,SET OF SEQUENCE OF, (different order)
44237 .*---------------------------------------------------------------------*
44240 <TC - DECODING ,SET OF SEQUENCE OF, (different order)>
44249 BERPDU ::= SET OF SEQUENCE OF INTEGER
44255 import from TempA all;
44257 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44259 const BERPDU myValue := {
44276 if (dec_BER_PDU('311630090201050201060201073009020101020102020103'O) == myValue)
44278 {setverdict(pass);} else {setverdict(fail);}
44283 Overall verdict: pass
44289 .*---------------------------------------------------------------------*
44290 :h3. DECODING ,SET OF SEQUENCE OF, (different order2)
44291 .*---------------------------------------------------------------------*
44294 <TC - DECODING ,SET OF SEQUENCE OF, (different order2)>
44303 BERPDU ::= SET OF SEQUENCE OF INTEGER
44309 import from TempA all;
44311 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44313 const BERPDU myValue := {
44330 if (dec_BER_PDU('318030800201050201060201070000308002010102010202010300000000'O) == myValue)
44332 {setverdict(pass);} else {setverdict(fail);}
44337 Overall verdict: pass
44343 .*---------------------------------------------------------------------*
44344 :h3. DECODING DER,SET OF SET OF
44345 .*---------------------------------------------------------------------*
44348 <TC - DECODING DER,SET OF SET OF>
44357 BERPDU ::= SET OF SET OF INTEGER
44363 import from TempA all;
44365 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44367 const BERPDU myValue := {
44384 if (dec_BER_PDU('311631090201010201020201033109020105020106020107'O) == myValue)
44386 {setverdict(pass);} else {setverdict(fail);}
44391 Overall verdict: pass
44397 .*---------------------------------------------------------------------*
44398 :h3. DECODING CER,SET OF SET OF
44399 .*---------------------------------------------------------------------*
44402 <TC - DECODING CER,SET OF SET OF>
44411 BERPDU ::= SET OF SET OF INTEGER
44417 import from TempA all;
44419 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44421 const BERPDU myValue := {
44438 if (dec_BER_PDU('318031800201010201020201030000318002010502010602010700000000'O) == myValue)
44440 {setverdict(pass);} else {setverdict(fail);}
44445 Overall verdict: pass
44451 .*---------------------------------------------------------------------*
44452 :h3. DECODING ,SET OF SET OF (different order)
44453 .*---------------------------------------------------------------------*
44456 <TC - DECODING ,SET OF SET OF (different order)>
44465 BERPDU ::= SET OF SET OF INTEGER
44471 import from TempA all;
44473 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44475 const BERPDU myValue := {
44492 if (dec_BER_PDU('311631090201050201060201073109020101020102020103'O) == myValue)
44494 {setverdict(pass);} else {setverdict(fail);}
44499 Overall verdict: pass
44505 .*---------------------------------------------------------------------*
44506 :h3. DECODING ,SET OF SET OF (different order2)
44507 .*---------------------------------------------------------------------*
44510 <TC - DECODING ,SET OF SET OF (different order2)>
44519 BERPDU ::= SET OF SET OF INTEGER
44525 import from TempA all;
44527 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44529 const BERPDU myValue := {
44546 if (dec_BER_PDU('318031800201050201060201070000318002010102010202010300000000'O) == myValue)
44548 {setverdict(pass);} else {setverdict(fail);}
44553 Overall verdict: pass
44559 .*---------------------------------------------------------------------*
44560 :h3. DECODING DER,TAGGED SET OF BOOLEAN
44561 .*---------------------------------------------------------------------*
44564 <TC - DECODING DER,TAGGED SET OF BOOLEAN>
44573 BERPDU ::= [0] SET OF BOOLEAN
44579 import from TempA all;
44581 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44583 const BERPDU myValue := {true, false }
44588 if (dec_BER_PDU('A00831060101000101FF'O) == myValue)
44590 {setverdict(pass);} else {setverdict(fail);}
44595 Overall verdict: pass
44601 .*---------------------------------------------------------------------*
44602 :h3. DECODING CER,TAGGED SET OF BOOLEAN
44603 .*---------------------------------------------------------------------*
44606 <TC - DECODING CER,TAGGED SET OF BOOLEAN>
44615 BERPDU ::= [0] SET OF BOOLEAN
44621 import from TempA all;
44623 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44625 const BERPDU myValue := {true, false }
44630 if (dec_BER_PDU('A08031800101000101FF00000000'O) == myValue)
44632 {setverdict(pass);} else {setverdict(fail);}
44637 Overall verdict: pass
44643 .*---------------------------------------------------------------------*
44644 :h3. DECODING ,TAGGED SET OF BOOLEAN (different order)
44645 .*---------------------------------------------------------------------*
44648 <TC - DECODING ,TAGGED SET OF BOOLEAN (different order)>
44657 BERPDU ::= [0] SET OF BOOLEAN
44663 import from TempA all;
44665 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44667 const BERPDU myValue := {true, false }
44672 if (dec_BER_PDU('A00831060101FF010100'O) == myValue)
44674 {setverdict(pass);} else {setverdict(fail);}
44679 Overall verdict: pass
44685 .*---------------------------------------------------------------------*
44686 :h3. DECODING ,TAGGED SET OF BOOLEAN (different order2)
44687 .*---------------------------------------------------------------------*
44690 <TC - DECODING ,TAGGED SET OF BOOLEAN (different order2)>
44699 BERPDU ::= [0] SET OF BOOLEAN
44705 import from TempA all;
44707 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44709 const BERPDU myValue := {true, false }
44714 if (dec_BER_PDU('A08031800101FF01010000000000'O) == myValue)
44716 {setverdict(pass);} else {setverdict(fail);}
44721 Overall verdict: pass
44727 .*---------------------------------------------------------------------*
44728 :h3. DECODING DER,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING
44729 .*---------------------------------------------------------------------*
44732 <TC - DECODING DER,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING>
44745 BERPDU ::= [0] SET OF BOOLEAN
44751 import from TempA all;
44753 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44755 const BERPDU myValue := {true, false }
44760 if (dec_BER_PDU('A00831060101000101FF'O) == myValue)
44762 {setverdict(pass);} else {setverdict(fail);}
44767 Overall verdict: pass
44773 .*---------------------------------------------------------------------*
44774 :h3. DECODING CER,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING
44775 .*---------------------------------------------------------------------*
44778 <TC - DECODING CER,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING>
44791 BERPDU ::= [0] SET OF BOOLEAN
44797 import from TempA all;
44799 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44801 const BERPDU myValue := {true, false }
44806 if (dec_BER_PDU('A08031800101000101FF00000000'O) == myValue)
44808 {setverdict(pass);} else {setverdict(fail);}
44813 Overall verdict: pass
44819 .*---------------------------------------------------------------------*
44820 :h3. DECODING ,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING (different order)
44821 .*---------------------------------------------------------------------*
44824 <TC - DECODING ,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING (different order)>
44837 BERPDU ::= [0] SET OF BOOLEAN
44843 import from TempA all;
44845 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44847 const BERPDU myValue := {true, false }
44852 if (dec_BER_PDU('A00831060101FF010100'O) == myValue)
44854 {setverdict(pass);} else {setverdict(fail);}
44859 Overall verdict: pass
44865 .*---------------------------------------------------------------------*
44866 :h3. DECODING ,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING (different order2)
44867 .*---------------------------------------------------------------------*
44870 <TC - DECODING ,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING (different order2)>
44883 BERPDU ::= [0] SET OF BOOLEAN
44889 import from TempA all;
44891 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44893 const BERPDU myValue := {true, false }
44898 if (dec_BER_PDU('A08031800101FF01010000000000'O) == myValue)
44900 {setverdict(pass);} else {setverdict(fail);}
44905 Overall verdict: pass
44911 .*---------------------------------------------------------------------*
44912 :h3. DECODING DER,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING
44913 .*---------------------------------------------------------------------*
44916 <TC - DECODING DER,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING>
44929 BERPDU ::= [0] SET OF BOOLEAN
44935 import from TempA all;
44937 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44939 const BERPDU myValue := {true, false }
44944 if (dec_BER_PDU('A0060101000101FF'O) == myValue)
44946 {setverdict(pass);} else {setverdict(fail);}
44951 Overall verdict: pass
44957 .*---------------------------------------------------------------------*
44958 :h3. DECODING CER,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING
44959 .*---------------------------------------------------------------------*
44962 <TC - DECODING CER,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING>
44975 BERPDU ::= [0] SET OF BOOLEAN
44981 import from TempA all;
44983 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44985 const BERPDU myValue := {true, false }
44990 if (dec_BER_PDU('A0800101000101FF0000'O) == myValue)
44992 {setverdict(pass);} else {setverdict(fail);}
44997 Overall verdict: pass
45003 .*---------------------------------------------------------------------*
45004 :h3. DECODING ,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING (different order)
45005 .*---------------------------------------------------------------------*
45008 <TC - DECODING ,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING (different order)>
45021 BERPDU ::= [0] SET OF BOOLEAN
45027 import from TempA all;
45029 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
45031 const BERPDU myValue := {true, false }
45036 if (dec_BER_PDU('A0060101FF010100'O) == myValue)
45038 {setverdict(pass);} else {setverdict(fail);}
45043 Overall verdict: pass
45049 .*---------------------------------------------------------------------*
45050 :h3. DECODING ,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING (different order2)
45051 .*---------------------------------------------------------------------*
45054 <TC - DECODING ,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING (different order2)>
45067 BERPDU ::= [0] SET OF BOOLEAN
45073 import from TempA all;
45075 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
45077 const BERPDU myValue := {true, false }
45082 if (dec_BER_PDU('A0800101FF0101000000'O) == myValue)
45084 {setverdict(pass);} else {setverdict(fail);}
45089 Overall verdict: pass
45095 .*---------------------------------------------------------------------*
45096 :h3.CER + DER encoding of CHOICE - NULL
45097 .*---------------------------------------------------------------------*
45100 <TC - CER + DER encoding of CHOICE - NULL>
45114 d ENUMERATED {first ,second ,third},
45119 h OBJECT IDENTIFIER,
45121 j CHOICE {x1 [1] BOOLEAN,
45122 y1 [2] OCTET STRING},
45124 k SEQUENCE{x2 NULL,
45127 l SET { x3 BIT STRING,
45130 m [3] SEQUENCE OF INTEGER,
45131 n [4] SET OF BOOLEAN
45139 import from TempA all;
45140 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45141 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45143 const BERPDU myValue := {a := NULL}
45150 if ((enc_DER_PDU(myValue) == '0500'O)and(enc_CER_PDU(myValue) == '0500'O)) {setverdict(pass);} else {setverdict(fail);}
45154 Overall verdict: pass
45160 .*---------------------------------------------------------------------*
45161 :h3.CER + DER encoding of CHOICE - BOOLEAN
45162 .*---------------------------------------------------------------------*
45165 <TC - CER + DER encoding of CHOICE - BOOLEAN>
45179 d ENUMERATED {first ,second ,third},
45184 h OBJECT IDENTIFIER,
45186 j CHOICE {x1 [1] BOOLEAN,
45187 y1 [2] OCTET STRING},
45189 k SEQUENCE{x2 NULL,
45192 l SET { x3 BIT STRING,
45195 m [3] SEQUENCE OF INTEGER,
45196 n [4] SET OF BOOLEAN
45204 import from TempA all;
45205 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45206 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45208 const BERPDU myValue := {b := true}
45215 if ((enc_DER_PDU(myValue) == '0101FF'O)and(enc_CER_PDU(myValue) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);}
45219 Overall verdict: pass
45225 .*---------------------------------------------------------------------*
45226 :h3.CER + DER encoding of CHOICE - INTEGER
45227 .*---------------------------------------------------------------------*
45230 <TC - CER + DER encoding of CHOICE - INTEGER>
45244 d ENUMERATED {first ,second ,third},
45249 h OBJECT IDENTIFIER,
45251 j CHOICE {x1 [1] BOOLEAN,
45252 y1 [2] OCTET STRING},
45254 k SEQUENCE{x2 NULL,
45257 l SET { x3 BIT STRING,
45260 m [3] SEQUENCE OF INTEGER,
45261 n [4] SET OF BOOLEAN
45269 import from TempA all;
45270 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45271 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45273 const BERPDU myValue := {c := 2}
45280 if ((enc_DER_PDU(myValue) == '020102'O)and(enc_CER_PDU(myValue) == '020102'O)) {setverdict(pass);} else {setverdict(fail);}
45284 Overall verdict: pass
45290 .*---------------------------------------------------------------------*
45291 :h3.CER + DER encoding of CHOICE - ENUMERATED
45292 .*---------------------------------------------------------------------*
45295 <TC - CER + DER encoding of CHOICE - ENUMERATED>
45309 d ENUMERATED {first ,second ,third},
45314 h OBJECT IDENTIFIER,
45316 j CHOICE {x1 [1] BOOLEAN,
45317 y1 [2] OCTET STRING},
45319 k SEQUENCE{x2 NULL,
45322 l SET { x3 BIT STRING,
45325 m [3] SEQUENCE OF INTEGER,
45326 n [4] SET OF BOOLEAN
45334 import from TempA all;
45335 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45336 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45338 const BERPDU myValue := {d := first}
45345 if ((enc_DER_PDU(myValue) == '0A0100'O)and(enc_CER_PDU(myValue) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);}
45349 Overall verdict: pass
45355 .*---------------------------------------------------------------------*
45356 :h3.CER + DER encoding of CHOICE - REAL
45357 .*---------------------------------------------------------------------*
45360 <TC - CER + DER encoding of CHOICE - REAL>
45374 d ENUMERATED {first ,second ,third},
45379 h OBJECT IDENTIFIER,
45381 j CHOICE {x1 [1] BOOLEAN,
45382 y1 [2] OCTET STRING},
45384 k SEQUENCE{x2 NULL,
45387 l SET { x3 BIT STRING,
45390 m [3] SEQUENCE OF INTEGER,
45391 n [4] SET OF BOOLEAN
45399 import from TempA all;
45400 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45401 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45403 const BERPDU myValue := {e := 1.0}
45410 if ((enc_DER_PDU(myValue) == '090603312E452B30'O)and(enc_CER_PDU(myValue) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
45414 Overall verdict: pass
45420 .*---------------------------------------------------------------------*
45421 :h3.CER + DER encoding of CHOICE - BIT STRING
45422 .*---------------------------------------------------------------------*
45425 <TC - CER + DER encoding of CHOICE - BIT STRING>
45439 d ENUMERATED {first ,second ,third},
45444 h OBJECT IDENTIFIER,
45446 j CHOICE {x1 [1] BOOLEAN,
45447 y1 [2] OCTET STRING},
45449 k SEQUENCE{x2 NULL,
45452 l SET { x3 BIT STRING,
45455 m [3] SEQUENCE OF INTEGER,
45456 n [4] SET OF BOOLEAN
45464 import from TempA all;
45465 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45466 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45468 const BERPDU myValue := {f := '1'B}
45475 if ((enc_DER_PDU(myValue) == '03020780'O)and(enc_CER_PDU(myValue) == '03020780'O)) {setverdict(pass);} else {setverdict(fail);}
45479 Overall verdict: pass
45485 .*---------------------------------------------------------------------*
45486 :h3.CER + DER encoding of CHOICE - OCTET STRING
45487 .*---------------------------------------------------------------------*
45490 <TC - CER + DER encoding of CHOICE - OCTET STRING>
45504 d ENUMERATED {first ,second ,third},
45509 h OBJECT IDENTIFIER,
45511 j CHOICE {x1 [1] BOOLEAN,
45512 y1 [2] OCTET STRING},
45514 k SEQUENCE{x2 NULL,
45517 l SET { x3 BIT STRING,
45520 m [3] SEQUENCE OF INTEGER,
45521 n [4] SET OF BOOLEAN
45529 import from TempA all;
45530 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45531 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45533 const BERPDU myValue := {g := 'FFFF'O}
45540 if ((enc_DER_PDU(myValue) == '0402FFFF'O)and(enc_CER_PDU(myValue) == '0402FFFF'O)) {setverdict(pass);} else {setverdict(fail);}
45544 Overall verdict: pass
45550 .*---------------------------------------------------------------------*
45551 :h3.CER + DER encoding of CHOICE - OBJECT IDENTIFIER
45552 .*---------------------------------------------------------------------*
45555 <TC - CER + DER encoding of CHOICE - OBJECT IDENTIFIER>
45569 d ENUMERATED {first ,second ,third},
45574 h OBJECT IDENTIFIER,
45576 j CHOICE {x1 [1] BOOLEAN,
45577 y1 [2] OCTET STRING},
45579 k SEQUENCE{x2 NULL,
45582 l SET { x3 BIT STRING,
45585 m [3] SEQUENCE OF INTEGER,
45586 n [4] SET OF BOOLEAN
45591 myValue BERPDU ::= h : {itu-t(0) recommendation(0) a(2) b(3)}
45599 import from TempA all;
45600 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45601 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45609 if ((enc_DER_PDU(myValue) == '0603000203'O)and(enc_CER_PDU(myValue) == '0603000203'O)) {setverdict(pass);} else {setverdict(fail);}
45613 Overall verdict: pass
45619 .*---------------------------------------------------------------------*
45620 :h3.CER + DER encoding of CHOICE - IA5String
45621 .*---------------------------------------------------------------------*
45624 <TC - CER + DER encoding of CHOICE - IA5String>
45638 d ENUMERATED {first ,second ,third},
45643 h OBJECT IDENTIFIER,
45645 j CHOICE {x1 [1] BOOLEAN,
45646 y1 [2] OCTET STRING},
45648 k SEQUENCE{x2 NULL,
45651 l SET { x3 BIT STRING,
45654 m [3] SEQUENCE OF INTEGER,
45655 n [4] SET OF BOOLEAN
45663 import from TempA all;
45664 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45665 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45667 const BERPDU myValue := {i := "ABC"}
45674 if ((enc_DER_PDU(myValue) == '1603414243'O)and(enc_CER_PDU(myValue) == '1603414243'O)) {setverdict(pass);} else {setverdict(fail);}
45678 Overall verdict: pass
45684 .*---------------------------------------------------------------------*
45685 :h3.CER + DER encoding of CHOICE - CHOICE
45686 .*---------------------------------------------------------------------*
45689 <TC - CER + DER encoding of CHOICE - CHOICE>
45703 d ENUMERATED {first ,second ,third},
45708 h OBJECT IDENTIFIER,
45710 j CHOICE {x1 [1] BOOLEAN,
45711 y1 [2] OCTET STRING},
45713 k SEQUENCE{x2 NULL,
45716 l SET { x3 BIT STRING,
45719 m [3] SEQUENCE OF INTEGER,
45720 n [4] SET OF BOOLEAN
45728 import from TempA all;
45729 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45730 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45732 const BERPDU myValue := {j := {x1 := true } }
45739 if ((enc_DER_PDU(myValue) == 'A1030101FF'O)and(enc_CER_PDU(myValue) == 'A1800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
45743 Overall verdict: pass
45749 .*---------------------------------------------------------------------*
45750 :h3.CER + DER encoding of CHOICE - SEQUENCE
45751 .*---------------------------------------------------------------------*
45754 <TC - CER + DER encoding of CHOICE - SEQUENCE>
45768 d ENUMERATED {first ,second ,third},
45773 h OBJECT IDENTIFIER,
45775 j CHOICE {x1 [1] BOOLEAN,
45776 y1 [2] OCTET STRING},
45778 k SEQUENCE{x2 NULL,
45781 l SET { x3 BIT STRING,
45784 m [3] SEQUENCE OF INTEGER,
45785 n [4] SET OF BOOLEAN
45793 import from TempA all;
45794 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45795 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45797 const BERPDU myValue := {k := {x2 := NULL,
45806 if ((enc_DER_PDU(myValue) == '300505000101FF'O)and(enc_CER_PDU(myValue) == '308005000101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
45810 Overall verdict: pass
45816 .*---------------------------------------------------------------------*
45817 :h3.CER + DER encoding of CHOICE - SET
45818 .*---------------------------------------------------------------------*
45821 <TC - CER + DER encoding of CHOICE - SET>
45835 d ENUMERATED {first ,second ,third},
45840 h OBJECT IDENTIFIER,
45842 j CHOICE {x1 [1] BOOLEAN,
45843 y1 [2] OCTET STRING},
45845 k SEQUENCE{x2 NULL,
45848 l SET { x3 BIT STRING,
45851 m [3] SEQUENCE OF INTEGER,
45852 n [4] SET OF BOOLEAN
45860 import from TempA all;
45861 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45862 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45864 const BERPDU myValue := {l := {y3 := 1.0 ,
45873 if ((enc_DER_PDU(myValue) == '310C03020780090603312E452B30'O)and(enc_CER_PDU(myValue) == '318003020780090603312E452B300000'O)) {setverdict(pass);} else {setverdict(fail);}
45877 Overall verdict: pass
45883 .*---------------------------------------------------------------------*
45884 :h3.CER + DER encoding of CHOICE - SEQUENCE OF
45885 .*---------------------------------------------------------------------*
45888 <TC - CER + DER encoding of CHOICE - SEQUENCE OF>
45902 d ENUMERATED {first ,second ,third},
45907 h OBJECT IDENTIFIER,
45909 j CHOICE {x1 [1] BOOLEAN,
45910 y1 [2] OCTET STRING},
45912 k SEQUENCE{x2 NULL,
45915 l SET { x3 BIT STRING,
45918 m [3] SEQUENCE OF INTEGER,
45919 n [4] SET OF BOOLEAN
45927 import from TempA all;
45928 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45929 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45931 const BERPDU myValue := {m :=
45939 if ((enc_DER_PDU(myValue) == 'A3083006020101020102'O)and(enc_CER_PDU(myValue) == 'A380308002010102010200000000'O)) {setverdict(pass);} else {setverdict(fail);}
45943 Overall verdict: pass
45949 .*---------------------------------------------------------------------*
45950 :h3.CER + DER encoding of CHOICE - SET OF
45951 .*---------------------------------------------------------------------*
45954 <TC - CER + DER encoding of CHOICE - SET OF>
45968 d ENUMERATED {first ,second ,third},
45973 h OBJECT IDENTIFIER,
45975 j CHOICE {x1 [1] BOOLEAN,
45976 y1 [2] OCTET STRING},
45978 k SEQUENCE{x2 NULL,
45981 l SET { x3 BIT STRING,
45984 m [3] SEQUENCE OF INTEGER,
45985 n [4] SET OF BOOLEAN
45993 import from TempA all;
45994 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45995 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45997 const BERPDU myValue := {n :=
46005 if ((enc_DER_PDU(myValue) == 'A40831060101FF0101FF'O)and(enc_CER_PDU(myValue) == 'A48031800101FF0101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
46009 Overall verdict: pass
46015 .*---------------------------------------------------------------------*
46016 :h3.CER + DER encoding of CHOICE - Default IMPLICIT TAGS, CHOICE untagged
46017 .*---------------------------------------------------------------------*
46020 <TC - CER + DER encoding of CHOICE - Default IMPLICIT TAGS, CHOICE untagged>
46045 import from TempA all;
46046 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46047 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46049 const BERPDU myValue := {b := true }
46056 if ((enc_DER_PDU(myValue) == '0101FF'O)and(enc_CER_PDU(myValue) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);}
46061 Overall verdict: pass
46067 .*---------------------------------------------------------------------*
46068 :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, CHOICE untagged
46069 .*---------------------------------------------------------------------*
46072 <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, CHOICE untagged>
46097 import from TempA all;
46098 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46099 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46101 const BERPDU myValue := {b := true }
46108 if ((enc_DER_PDU(myValue) == '0101FF'O)and(enc_CER_PDU(myValue) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);}
46113 Overall verdict: pass
46119 .*---------------------------------------------------------------------*
46120 :h3.CER + DER encoding of CHOICE - No Default TAGS, CHOICE untagged
46121 .*---------------------------------------------------------------------*
46124 <TC - CER + DER encoding of CHOICE - No Default TAGS, CHOICE untagged>
46148 import from TempA all;
46149 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46150 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46152 const BERPDU myValue := {b := true }
46159 if ((enc_DER_PDU(myValue) == '0101FF'O)and(enc_CER_PDU(myValue) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);}
46164 Overall verdict: pass
46170 .*---------------------------------------------------------------------*
46171 :h3.CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, CHOICE untagged
46172 .*---------------------------------------------------------------------*
46175 <TC - CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, CHOICE untagged>
46200 import from TempA all;
46201 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46202 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46204 const BERPDU myValue := {b := true }
46211 if ((enc_DER_PDU(myValue) == '8001FF'O)and(enc_CER_PDU(myValue) == '8001FF'O)) {setverdict(pass);} else {setverdict(fail);}
46216 Overall verdict: pass
46222 .*---------------------------------------------------------------------*
46223 :h3.CER + DER encoding of CHOICE - Default IMPLICIT TAGS, number-tagged CHOICE
46224 .*---------------------------------------------------------------------*
46227 <TC - CER + DER encoding of CHOICE - Default IMPLICIT TAGS, number-tagged CHOICE>
46252 import from TempA all;
46253 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46254 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46256 const BERPDU myValue := {b := true }
46263 if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);}
46268 Overall verdict: pass
46274 .*---------------------------------------------------------------------*
46275 :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE
46276 .*---------------------------------------------------------------------*
46279 <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE>
46304 import from TempA all;
46305 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46306 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46308 const BERPDU myValue := {b := true }
46315 if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
46320 Overall verdict: pass
46326 .*---------------------------------------------------------------------*
46327 :h3.CER + DER encoding of CHOICE - No Default TAGS, number-tagged CHOICE
46328 .*---------------------------------------------------------------------*
46331 <TC - CER + DER encoding of CHOICE - No Default TAGS, number-tagged CHOICE>
46351 import from TempA all;
46352 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46353 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46355 const BERPDU myValue := {b := true }
46362 if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
46367 Overall verdict: pass
46373 .*---------------------------------------------------------------------*
46374 :h3.CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE
46375 .*---------------------------------------------------------------------*
46378 <TC - CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE>
46403 import from TempA all;
46404 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46405 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46407 const BERPDU myValue := {b := true }
46414 if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);}
46419 Overall verdict: pass
46425 .*---------------------------------------------------------------------*
46426 :h3.CER + DER encoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE
46427 .*---------------------------------------------------------------------*
46430 <TC - CER + DER encoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE>
46446 b [3] IMPLICIT BOOLEAN,
46455 import from TempA all;
46456 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46457 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46459 const BERPDU myValue := {b := true }
46466 if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);}
46471 Overall verdict: pass
46477 .*---------------------------------------------------------------------*
46478 :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
46479 .*---------------------------------------------------------------------*
46482 <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
46498 b [3] IMPLICIT BOOLEAN,
46507 import from TempA all;
46508 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46509 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46511 const BERPDU myValue := {b := true }
46518 if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);}
46523 Overall verdict: pass
46529 .*---------------------------------------------------------------------*
46530 :h3.CER + DER encoding of CHOICE - No Default TAGS, fully-tagged CHOICE
46531 .*---------------------------------------------------------------------*
46534 <TC - CER + DER encoding of CHOICE - No Default TAGS, fully-tagged CHOICE>
46549 b [3] IMPLICIT BOOLEAN,
46558 import from TempA all;
46559 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46560 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46562 const BERPDU myValue := {b := true }
46569 if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);}
46574 Overall verdict: pass
46580 .*---------------------------------------------------------------------*
46581 :h3.CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE
46582 .*---------------------------------------------------------------------*
46585 <TC - CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE>
46601 b [3] IMPLICIT BOOLEAN,
46610 import from TempA all;
46611 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46612 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46614 const BERPDU myValue := {b := true }
46621 if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);}
46626 Overall verdict: pass
46632 .*---------------------------------------------------------------------*
46633 :h3.CER + DER encoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE
46634 .*---------------------------------------------------------------------*
46637 <TC - CER + DER encoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE>
46653 b [3] EXPLICIT BOOLEAN,
46662 import from TempA all;
46663 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46664 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46666 const BERPDU myValue := {b := true }
46673 if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
46678 Overall verdict: pass
46684 .*---------------------------------------------------------------------*
46685 :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
46686 .*---------------------------------------------------------------------*
46689 <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
46705 b [3] EXPLICIT BOOLEAN,
46714 import from TempA all;
46715 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46716 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46718 const BERPDU myValue := {b := true }
46725 if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
46730 Overall verdict: pass
46736 .*---------------------------------------------------------------------*
46737 :h3.CER + DER encoding of CHOICE - No Default TAGS, fully-tagged CHOICE
46738 .*---------------------------------------------------------------------*
46741 <TC - CER + DER encoding of CHOICE - No Default TAGS, fully-tagged CHOICE>
46756 b [3] EXPLICIT BOOLEAN,
46765 import from TempA all;
46766 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46767 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46769 const BERPDU myValue := {b := true }
46776 if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
46781 Overall verdict: pass
46787 .*---------------------------------------------------------------------*
46788 :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
46789 .*---------------------------------------------------------------------*
46792 <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
46808 b [3] EXPLICIT BOOLEAN,
46817 import from TempA all;
46818 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46819 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46821 const BERPDU myValue := {b := true }
46828 if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
46833 Overall verdict: pass
46839 .*---------------------------------------------------------------------*
46840 :h3.CER + DER encoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,
46841 .*---------------------------------------------------------------------*
46844 <TC - CER + DER encoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,>
46858 BERPDU ::= [0] CHOICE
46869 import from TempA all;
46870 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46871 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46873 const BERPDU myValue := {b := true }
46880 if ((enc_DER_PDU(myValue) == 'A0038301FF'O)and(enc_CER_PDU(myValue) == 'A0808301FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
46885 Overall verdict: pass
46891 .*---------------------------------------------------------------------*
46892 :h3.CER + DER encoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,
46893 .*---------------------------------------------------------------------*
46896 <TC - CER + DER encoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,>
46910 BERPDU ::= [0] CHOICE
46921 import from TempA all;
46922 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46923 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46925 const BERPDU myValue := {b := true }
46932 if ((enc_DER_PDU(myValue) == 'A005A3030101FF'O)and(enc_CER_PDU(myValue) == 'A080A3800101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
46937 Overall verdict: pass
46943 .*---------------------------------------------------------------------*
46944 :h3.CER + DER encoding of CHOICE, NO DEFAULT, TAGGED CHOICE,
46945 .*---------------------------------------------------------------------*
46948 <TC - CER + DER encoding of CHOICE, NO DEFAULT, TAGGED CHOICE,>
46962 BERPDU ::= [0] CHOICE
46973 import from TempA all;
46974 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46975 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46977 const BERPDU myValue := {b := true }
46984 if ((enc_DER_PDU(myValue) == 'A005A3030101FF'O)and(enc_CER_PDU(myValue) == 'A080A3800101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
46989 Overall verdict: pass
46995 .*---------------------------------------------------------------------*
46996 :h3.CER + DER encoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,
46997 .*---------------------------------------------------------------------*
47000 <TC - CER + DER encoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,>
47014 BERPDU ::= [0] CHOICE
47025 import from TempA all;
47026 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
47027 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
47029 const BERPDU myValue := {b := true }
47036 if ((enc_DER_PDU(myValue) == 'A0038301FF'O)and(enc_CER_PDU(myValue) == 'A0808301FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
47041 Overall verdict: pass
47047 .*---------------------------------------------------------------------*
47048 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - NULL
47049 .*---------------------------------------------------------------------*
47052 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - NULL>
47065 d ENUMERATED {first ,second ,third},
47070 h OBJECT IDENTIFIER,
47072 j CHOICE {x1 [1] BOOLEAN,
47073 y1 [2] OCTET STRING},
47075 k SEQUENCE{x2 NULL,
47078 l SET { x3 BIT STRING,
47081 m [3] SEQUENCE OF INTEGER,
47082 n [4] SET OF BOOLEAN
47088 import from TempA all;
47090 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47091 const BERPDU myValue := {a := NULL}
47095 if (dec_BER_PDU('0500'O) == myValue)
47098 {setverdict(pass);} else {setverdict(fail);}
47103 Overall verdict: pass
47109 .*---------------------------------------------------------------------*
47110 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - BOOLEAN
47111 .*---------------------------------------------------------------------*
47114 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - BOOLEAN>
47127 d ENUMERATED {first ,second ,third},
47132 h OBJECT IDENTIFIER,
47134 j CHOICE {x1 [1] BOOLEAN,
47135 y1 [2] OCTET STRING},
47137 k SEQUENCE{x2 NULL,
47140 l SET { x3 BIT STRING,
47143 m [3] SEQUENCE OF INTEGER,
47144 n [4] SET OF BOOLEAN
47150 import from TempA all;
47152 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47153 const BERPDU myValue := {b := true}
47157 if (dec_BER_PDU('0101FF'O) == myValue)
47160 {setverdict(pass);} else {setverdict(fail);}
47165 Overall verdict: pass
47171 .*---------------------------------------------------------------------*
47172 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - INTEGER
47173 .*---------------------------------------------------------------------*
47176 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - INTEGER>
47189 d ENUMERATED {first ,second ,third},
47194 h OBJECT IDENTIFIER,
47196 j CHOICE {x1 [1] BOOLEAN,
47197 y1 [2] OCTET STRING},
47199 k SEQUENCE{x2 NULL,
47202 l SET { x3 BIT STRING,
47205 m [3] SEQUENCE OF INTEGER,
47206 n [4] SET OF BOOLEAN
47212 import from TempA all;
47214 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47215 const BERPDU myValue := {c := 2}
47219 if (dec_BER_PDU('020102'O) == myValue)
47222 {setverdict(pass);} else {setverdict(fail);}
47227 Overall verdict: pass
47233 .*---------------------------------------------------------------------*
47234 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - ENUMERATED
47235 .*---------------------------------------------------------------------*
47238 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - ENUMERATED>
47251 d ENUMERATED {first ,second ,third},
47256 h OBJECT IDENTIFIER,
47258 j CHOICE {x1 [1] BOOLEAN,
47259 y1 [2] OCTET STRING},
47261 k SEQUENCE{x2 NULL,
47264 l SET { x3 BIT STRING,
47267 m [3] SEQUENCE OF INTEGER,
47268 n [4] SET OF BOOLEAN
47274 import from TempA all;
47276 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47277 const BERPDU myValue := {d := first}
47281 if (dec_BER_PDU('0A0100'O) == myValue)
47284 {setverdict(pass);} else {setverdict(fail);}
47289 Overall verdict: pass
47295 .*---------------------------------------------------------------------*
47296 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - BIT STRING
47297 .*---------------------------------------------------------------------*
47300 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - BIT STRING>
47313 d ENUMERATED {first ,second ,third},
47318 h OBJECT IDENTIFIER,
47320 j CHOICE {x1 [1] BOOLEAN,
47321 y1 [2] OCTET STRING},
47323 k SEQUENCE{x2 NULL,
47326 l SET { x3 BIT STRING,
47329 m [3] SEQUENCE OF INTEGER,
47330 n [4] SET OF BOOLEAN
47336 import from TempA all;
47338 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47339 const BERPDU myValue := {f := '1'B}
47343 if (dec_BER_PDU('03020780'O) == myValue)
47346 {setverdict(pass);} else {setverdict(fail);}
47351 Overall verdict: pass
47357 .*---------------------------------------------------------------------*
47358 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - OCTET STRING
47359 .*---------------------------------------------------------------------*
47362 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - OCTET STRING>
47375 d ENUMERATED {first ,second ,third},
47380 h OBJECT IDENTIFIER,
47382 j CHOICE {x1 [1] BOOLEAN,
47383 y1 [2] OCTET STRING},
47385 k SEQUENCE{x2 NULL,
47388 l SET { x3 BIT STRING,
47391 m [3] SEQUENCE OF INTEGER,
47392 n [4] SET OF BOOLEAN
47398 import from TempA all;
47400 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47401 const BERPDU myValue := {g := 'FFFF'O}
47405 if (dec_BER_PDU('0402FFFF'O) == myValue)
47408 {setverdict(pass);} else {setverdict(fail);}
47413 Overall verdict: pass
47419 .*---------------------------------------------------------------------*
47420 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - OBJECT IDENTIFIER
47421 .*---------------------------------------------------------------------*
47424 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - OBJECT IDENTIFIER>
47437 d ENUMERATED {first ,second ,third},
47442 h OBJECT IDENTIFIER,
47444 j CHOICE {x1 [1] BOOLEAN,
47445 y1 [2] OCTET STRING},
47447 k SEQUENCE{x2 NULL,
47450 l SET { x3 BIT STRING,
47453 m [3] SEQUENCE OF INTEGER,
47454 n [4] SET OF BOOLEAN
47457 myValue BERPDU ::= h : {itu-t(0) recommendation(0) a(2) b(3)}
47464 import from TempA all;
47466 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47470 if (dec_BER_PDU('0603000203'O) == myValue)
47473 {setverdict(pass);} else {setverdict(fail);}
47478 Overall verdict: pass
47484 .*---------------------------------------------------------------------*
47485 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - IA5String
47486 .*---------------------------------------------------------------------*
47489 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - IA5String>
47502 d ENUMERATED {first ,second ,third},
47507 h OBJECT IDENTIFIER,
47509 j CHOICE {x1 [1] BOOLEAN,
47510 y1 [2] OCTET STRING},
47512 k SEQUENCE{x2 NULL,
47515 l SET { x3 BIT STRING,
47518 m [3] SEQUENCE OF INTEGER,
47519 n [4] SET OF BOOLEAN
47528 import from TempA all;
47530 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47532 const BERPDU myValue := {i := "ABC"}
47537 if (dec_BER_PDU('1603414243'O) == myValue)
47540 {setverdict(pass);} else {setverdict(fail);}
47545 Overall verdict: pass
47551 .*---------------------------------------------------------------------*
47552 :h3. DECODING OBJECT IDENTIFIER ,DER, CHOICE - CHOICE
47553 .*---------------------------------------------------------------------*
47556 <TC - DECODING OBJECT IDENTIFIER ,DER, CHOICE - CHOICE>
47569 d ENUMERATED {first ,second ,third},
47574 h OBJECT IDENTIFIER,
47576 j CHOICE {x1 [1] BOOLEAN,
47577 y1 [2] OCTET STRING},
47579 k SEQUENCE{x2 NULL,
47582 l SET { x3 BIT STRING,
47585 m [3] SEQUENCE OF INTEGER,
47586 n [4] SET OF BOOLEAN
47595 import from TempA all;
47597 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47599 const BERPDU myValue := {j := {x1 := true } }
47604 if (dec_BER_PDU('A1030101FF'O) == myValue)
47607 {setverdict(pass);} else {setverdict(fail);}
47612 Overall verdict: pass
47618 .*---------------------------------------------------------------------*
47619 :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - CHOICE
47620 .*---------------------------------------------------------------------*
47623 <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - CHOICE>
47636 d ENUMERATED {first ,second ,third},
47641 h OBJECT IDENTIFIER,
47643 j CHOICE {x1 [1] BOOLEAN,
47644 y1 [2] OCTET STRING},
47646 k SEQUENCE{x2 NULL,
47649 l SET { x3 BIT STRING,
47652 m [3] SEQUENCE OF INTEGER,
47653 n [4] SET OF BOOLEAN
47662 import from TempA all;
47664 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47666 const BERPDU myValue := {j := {x1 := true } }
47671 if (dec_BER_PDU('A1800101FF0000'O) == myValue)
47674 {setverdict(pass);} else {setverdict(fail);}
47679 Overall verdict: pass
47685 .*---------------------------------------------------------------------*
47686 :h3. DECODING OBJECT IDENTIFIER , DER, CHOICE - SEQUENCE
47687 .*---------------------------------------------------------------------*
47690 <TC - DECODING OBJECT IDENTIFIER , DER, CHOICE - SEQUENCE>
47703 d ENUMERATED {first ,second ,third},
47708 h OBJECT IDENTIFIER,
47710 j CHOICE {x1 [1] BOOLEAN,
47711 y1 [2] OCTET STRING},
47713 k SEQUENCE{x2 NULL,
47716 l SET { x3 BIT STRING,
47719 m [3] SEQUENCE OF INTEGER,
47720 n [4] SET OF BOOLEAN
47729 import from TempA all;
47731 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47733 const BERPDU myValue := {k := {x2 := NULL,
47741 if (dec_BER_PDU('300505000101FF'O) == myValue)
47744 {setverdict(pass);} else {setverdict(fail);}
47749 Overall verdict: pass
47755 .*---------------------------------------------------------------------*
47756 :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - SEQUENCE
47757 .*---------------------------------------------------------------------*
47760 <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - SEQUENCE>
47773 d ENUMERATED {first ,second ,third},
47778 h OBJECT IDENTIFIER,
47780 j CHOICE {x1 [1] BOOLEAN,
47781 y1 [2] OCTET STRING},
47783 k SEQUENCE{x2 NULL,
47786 l SET { x3 BIT STRING,
47789 m [3] SEQUENCE OF INTEGER,
47790 n [4] SET OF BOOLEAN
47799 import from TempA all;
47801 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47803 const BERPDU myValue := {k := {x2 := NULL,
47811 if (dec_BER_PDU('308005000101FF0000'O) == myValue)
47814 {setverdict(pass);} else {setverdict(fail);}
47819 Overall verdict: pass
47825 .*---------------------------------------------------------------------*
47826 :h3. DECODING OBJECT IDENTIFIER , DER, CHOICE - SET
47827 .*---------------------------------------------------------------------*
47830 <TC - DECODING OBJECT IDENTIFIER , DER, CHOICE - SET>
47843 d ENUMERATED {first ,second ,third},
47848 h OBJECT IDENTIFIER,
47850 j CHOICE {x1 [1] BOOLEAN,
47851 y1 [2] OCTET STRING},
47853 k SEQUENCE{x2 NULL,
47856 l SET { x3 BIT STRING,
47859 m [3] SEQUENCE OF INTEGER,
47860 n [4] SET OF BOOLEAN
47869 import from TempA all;
47871 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47873 const BERPDU myValue := {l := {y3 := 'FFFF'O ,
47882 if (dec_BER_PDU('3108030207800402FFFF'O) == myValue)
47885 {setverdict(pass);} else {setverdict(fail);}
47890 Overall verdict: pass
47896 .*---------------------------------------------------------------------*
47897 :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - SET
47898 .*---------------------------------------------------------------------*
47901 <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - SET>
47914 d ENUMERATED {first ,second ,third},
47919 h OBJECT IDENTIFIER,
47921 j CHOICE {x1 [1] BOOLEAN,
47922 y1 [2] OCTET STRING},
47924 k SEQUENCE{x2 NULL,
47927 l SET { x3 BIT STRING,
47930 m [3] SEQUENCE OF INTEGER,
47931 n [4] SET OF BOOLEAN
47940 import from TempA all;
47942 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47944 const BERPDU myValue := {l := {y3 := 'FFFF'O ,
47953 if (dec_BER_PDU('3180030207800402FFFF0000'O) == myValue)
47956 {setverdict(pass);} else {setverdict(fail);}
47961 Overall verdict: pass
47967 .*---------------------------------------------------------------------*
47968 :h3. DECODING OBJECT IDENTIFIER , DER, CHOICE - SEQUENCE OF
47969 .*---------------------------------------------------------------------*
47972 <TC - DECODING OBJECT IDENTIFIER , DER, CHOICE - SEQUENCE OF>
47985 d ENUMERATED {first ,second ,third},
47990 h OBJECT IDENTIFIER,
47992 j CHOICE {x1 [1] BOOLEAN,
47993 y1 [2] OCTET STRING},
47995 k SEQUENCE{x2 NULL,
47998 l SET { x3 BIT STRING,
48001 m [3] SEQUENCE OF INTEGER,
48002 n [4] SET OF BOOLEAN
48011 import from TempA all;
48013 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48015 const BERPDU myValue := {m :=
48022 if (dec_BER_PDU('A3083006020101020102'O) == myValue)
48025 {setverdict(pass);} else {setverdict(fail);}
48030 Overall verdict: pass
48036 .*---------------------------------------------------------------------*
48037 :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - SEQUENCE OF
48038 .*---------------------------------------------------------------------*
48041 <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - SEQUENCE OF>
48054 d ENUMERATED {first ,second ,third},
48059 h OBJECT IDENTIFIER,
48061 j CHOICE {x1 [1] BOOLEAN,
48062 y1 [2] OCTET STRING},
48064 k SEQUENCE{x2 NULL,
48067 l SET { x3 BIT STRING,
48070 m [3] SEQUENCE OF INTEGER,
48071 n [4] SET OF BOOLEAN
48080 import from TempA all;
48082 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48084 const BERPDU myValue := {m :=
48091 if (dec_BER_PDU('A380308002010102010200000000'O) == myValue)
48094 {setverdict(pass);} else {setverdict(fail);}
48099 Overall verdict: pass
48105 .*---------------------------------------------------------------------*
48106 :h3. DECODING OBJECT IDENTIFIER , DER, CHOICE - SET OF
48107 .*---------------------------------------------------------------------*
48110 <TC - DECODING OBJECT IDENTIFIER , DER, CHOICE - SET OF>
48123 d ENUMERATED {first ,second ,third},
48128 h OBJECT IDENTIFIER,
48130 j CHOICE {x1 [1] BOOLEAN,
48131 y1 [2] OCTET STRING},
48133 k SEQUENCE{x2 NULL,
48136 l SET { x3 BIT STRING,
48139 m [3] SEQUENCE OF INTEGER,
48140 n [4] SET OF BOOLEAN
48149 import from TempA all;
48151 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48153 const BERPDU myValue := {n :=
48160 if (dec_BER_PDU('A40831060101FF0101FF'O) == myValue)
48163 {setverdict(pass);} else {setverdict(fail);}
48168 Overall verdict: pass
48174 .*---------------------------------------------------------------------*
48175 :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - SET OF
48176 .*---------------------------------------------------------------------*
48179 <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - SET OF>
48192 d ENUMERATED {first ,second ,third},
48197 h OBJECT IDENTIFIER,
48199 j CHOICE {x1 [1] BOOLEAN,
48200 y1 [2] OCTET STRING},
48202 k SEQUENCE{x2 NULL,
48205 l SET { x3 BIT STRING,
48208 m [3] SEQUENCE OF INTEGER,
48209 n [4] SET OF BOOLEAN
48218 import from TempA all;
48220 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48222 const BERPDU myValue := {n :=
48229 if (dec_BER_PDU('A48031800101FF0101FF00000000'O) == myValue)
48232 {setverdict(pass);} else {setverdict(fail);}
48237 Overall verdict: pass
48243 .*---------------------------------------------------------------------*
48244 :h3.CER + DER decoding of CHOICE - Default IMPLICIT TAGS, CHOICE untagged
48245 .*---------------------------------------------------------------------*
48248 <TC - CER + DER decoding of CHOICE - Default IMPLICIT TAGS, CHOICE untagged>
48273 import from TempA all;
48275 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48277 const BERPDU myValue := {b := true }
48283 if (dec_BER_PDU('0101FF'O) == myValue)
48286 {setverdict(pass);} else {setverdict(fail);}
48291 Overall verdict: pass
48297 .*---------------------------------------------------------------------*
48298 :h3.CER + DER decoding of CHOICE - Default EXPLICIT TAGS, CHOICE untagged
48299 .*---------------------------------------------------------------------*
48302 <TC - CER + DER decoding of CHOICE - Default EXPLICIT TAGS, CHOICE untagged>
48328 import from TempA all;
48330 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48332 const BERPDU myValue := {b := true }
48338 if (dec_BER_PDU('0101FF'O) == myValue)
48341 {setverdict(pass);} else {setverdict(fail);}
48346 Overall verdict: pass
48352 .*---------------------------------------------------------------------*
48353 :h3.CER + DER decoding of CHOICE - No Default TAGS, CHOICE untagged
48354 .*---------------------------------------------------------------------*
48357 <TC - CER + DER decoding of CHOICE - No Default TAGS, CHOICE untagged>
48383 import from TempA all;
48385 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48387 const BERPDU myValue := {b := true }
48393 if (dec_BER_PDU('0101FF'O) == myValue)
48396 {setverdict(pass);} else {setverdict(fail);}
48401 Overall verdict: pass
48407 .*---------------------------------------------------------------------*
48408 :h3.CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, CHOICE untagged
48409 .*---------------------------------------------------------------------*
48412 <TC - CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, CHOICE untagged>
48438 import from TempA all;
48440 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48442 const BERPDU myValue := {b := true }
48448 if (dec_BER_PDU('8001FF'O) == myValue)
48451 {setverdict(pass);} else {setverdict(fail);}
48456 Overall verdict: pass
48462 .*---------------------------------------------------------------------*
48463 :h3.CER + DER decoding of CHOICE - Default IMPLICIT TAGS, number-tagged CHOICE
48464 .*---------------------------------------------------------------------*
48467 <TC - CER + DER decoding of CHOICE - Default IMPLICIT TAGS, number-tagged CHOICE>
48496 import from TempA all;
48498 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48500 const BERPDU myValue := {b := true }
48506 if (dec_BER_PDU('8301FF'O) == myValue)
48509 {setverdict(pass);} else {setverdict(fail);}
48514 Overall verdict: pass
48520 .*---------------------------------------------------------------------*
48521 :h3. DER decoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE
48522 .*---------------------------------------------------------------------*
48525 <TC - DER decoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE>
48554 import from TempA all;
48556 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48558 const BERPDU myValue := {b := true }
48564 if (dec_BER_PDU('A3030101FF'O) == myValue)
48567 {setverdict(pass);} else {setverdict(fail);}
48572 Overall verdict: pass
48578 .*---------------------------------------------------------------------*
48579 :h3. CER decoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE
48580 .*---------------------------------------------------------------------*
48583 <TC - CER decoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE>
48610 import from TempA all;
48612 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48614 const BERPDU myValue := {b := true }
48620 if (dec_BER_PDU('A3800101FF0000'O) == myValue)
48623 {setverdict(pass);} else {setverdict(fail);}
48628 Overall verdict: pass
48634 .*---------------------------------------------------------------------*
48635 :h3. DER decoding of CHOICE - No Default TAGS, number-tagged CHOICE
48636 .*---------------------------------------------------------------------*
48639 <TC - DER decoding of CHOICE - No Default TAGS, number-tagged CHOICE>
48665 import from TempA all;
48667 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48669 const BERPDU myValue := {b := true }
48675 if (dec_BER_PDU('A3030101FF'O) == myValue)
48678 {setverdict(pass);} else {setverdict(fail);}
48683 Overall verdict: pass
48689 .*---------------------------------------------------------------------*
48690 :h3. CER decoding of CHOICE - No Default TAGS, number-tagged CHOICE
48691 .*---------------------------------------------------------------------*
48694 <TC - CER decoding of CHOICE - No Default TAGS, number-tagged CHOICE>
48721 import from TempA all;
48723 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48725 const BERPDU myValue := {b := true }
48731 if (dec_BER_PDU('A3800101FF0000'O) == myValue)
48734 {setverdict(pass);} else {setverdict(fail);}
48739 Overall verdict: pass
48745 .*---------------------------------------------------------------------*
48746 :h3. CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE
48747 .*---------------------------------------------------------------------*
48750 <TC - CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE>
48778 import from TempA all;
48780 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48782 const BERPDU myValue := {b := true }
48788 if (dec_BER_PDU('8301FF'O) == myValue)
48791 {setverdict(pass);} else {setverdict(fail);}
48796 Overall verdict: pass
48802 .*---------------------------------------------------------------------*
48803 :h3. CER + DER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE
48804 .*---------------------------------------------------------------------*
48807 <TC - CER + DER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE>
48823 b [3] IMPLICIT BOOLEAN,
48834 import from TempA all;
48836 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48838 const BERPDU myValue := {b := true }
48844 if (dec_BER_PDU('8301FF'O) == myValue)
48847 {setverdict(pass);} else {setverdict(fail);}
48852 Overall verdict: pass
48858 .*---------------------------------------------------------------------*
48859 :h3. CER + DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
48860 .*---------------------------------------------------------------------*
48863 <TC - CER + DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
48879 b [3] IMPLICIT BOOLEAN,
48890 import from TempA all;
48892 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48894 const BERPDU myValue := {b := true }
48900 if (dec_BER_PDU('8301FF'O) == myValue)
48903 {setverdict(pass);} else {setverdict(fail);}
48908 Overall verdict: pass
48914 .*---------------------------------------------------------------------*
48915 :h3. CER + DER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE
48916 .*---------------------------------------------------------------------*
48919 <TC - CER + DER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE>
48934 b [3] IMPLICIT BOOLEAN,
48945 import from TempA all;
48947 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48949 const BERPDU myValue := {b := true }
48955 if (dec_BER_PDU('8301FF'O) == myValue)
48958 {setverdict(pass);} else {setverdict(fail);}
48963 Overall verdict: pass
48969 .*---------------------------------------------------------------------*
48970 :h3. CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE
48971 .*---------------------------------------------------------------------*
48974 <TC - CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE>
48992 b [3] IMPLICIT BOOLEAN,
49004 import from TempA all;
49006 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49008 const BERPDU myValue := {b := true }
49014 if (dec_BER_PDU('8301FF'O) == myValue)
49017 {setverdict(pass);} else {setverdict(fail);}
49022 Overall verdict: pass
49028 .*---------------------------------------------------------------------*
49029 :h3. DER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE
49030 .*---------------------------------------------------------------------*
49033 <TC - DER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE>
49052 b [3] EXPLICIT BOOLEAN,
49063 import from TempA all;
49065 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49067 const BERPDU myValue := {b := true }
49073 if (dec_BER_PDU('A3030101FF'O) == myValue)
49076 {setverdict(pass);} else {setverdict(fail);}
49081 Overall verdict: pass
49087 .*---------------------------------------------------------------------*
49088 :h3. CER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE
49089 .*---------------------------------------------------------------------*
49092 <TC - CER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE>
49111 b [3] EXPLICIT BOOLEAN,
49122 import from TempA all;
49124 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49126 const BERPDU myValue := {b := true }
49132 if (dec_BER_PDU('A3800101FF0000'O) == myValue)
49135 {setverdict(pass);} else {setverdict(fail);}
49140 Overall verdict: pass
49146 .*---------------------------------------------------------------------*
49147 :h3. DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
49148 .*---------------------------------------------------------------------*
49151 <TC - DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
49170 b [3] EXPLICIT BOOLEAN,
49181 import from TempA all;
49183 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49185 const BERPDU myValue := {b := true }
49191 if (dec_BER_PDU('A3030101FF'O) == myValue)
49194 {setverdict(pass);} else {setverdict(fail);}
49199 Overall verdict: pass
49205 .*---------------------------------------------------------------------*
49206 :h3. CER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
49207 .*---------------------------------------------------------------------*
49210 <TC - CER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
49229 b [3] EXPLICIT BOOLEAN,
49240 import from TempA all;
49242 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49244 const BERPDU myValue := {b := true }
49250 if (dec_BER_PDU('A3800101FF0000'O) == myValue)
49253 {setverdict(pass);} else {setverdict(fail);}
49258 Overall verdict: pass
49264 .*---------------------------------------------------------------------*
49265 :h3. DER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE
49266 .*---------------------------------------------------------------------*
49269 <TC - DER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE>
49287 b [3] EXPLICIT BOOLEAN,
49298 import from TempA all;
49300 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49302 const BERPDU myValue := {b := true }
49308 if (dec_BER_PDU('A3030101FF'O) == myValue)
49311 {setverdict(pass);} else {setverdict(fail);}
49316 Overall verdict: pass
49322 .*---------------------------------------------------------------------*
49323 :h3. CER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE
49324 .*---------------------------------------------------------------------*
49327 <TC - CER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE>
49345 b [3] EXPLICIT BOOLEAN,
49356 import from TempA all;
49358 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49360 const BERPDU myValue := {b := true }
49366 if (dec_BER_PDU('A3800101FF0000'O) == myValue)
49369 {setverdict(pass);} else {setverdict(fail);}
49374 Overall verdict: pass
49380 .*---------------------------------------------------------------------*
49381 :h3. DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
49382 .*---------------------------------------------------------------------*
49385 <TC - DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
49404 b [3] EXPLICIT BOOLEAN,
49415 import from TempA all;
49417 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49419 const BERPDU myValue := {b := true }
49425 if (dec_BER_PDU('A3030101FF'O) == myValue)
49428 {setverdict(pass);} else {setverdict(fail);}
49433 Overall verdict: pass
49439 .*---------------------------------------------------------------------*
49440 :h3. CER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
49441 .*---------------------------------------------------------------------*
49444 <TC - CER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
49463 b [3] EXPLICIT BOOLEAN,
49474 import from TempA all;
49476 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49478 const BERPDU myValue := {b := true }
49484 if (dec_BER_PDU('A3800101FF0000'O) == myValue)
49487 {setverdict(pass);} else {setverdict(fail);}
49492 Overall verdict: pass
49498 .*---------------------------------------------------------------------*
49499 :h3. DER decoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,
49500 .*---------------------------------------------------------------------*
49503 <TC - DER decoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,>
49521 BERPDU ::= [0] CHOICE
49534 import from TempA all;
49536 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49538 const BERPDU myValue := {b := true }
49544 if (dec_BER_PDU('A0038301FF'O) == myValue)
49547 {setverdict(pass);} else {setverdict(fail);}
49552 Overall verdict: pass
49558 .*---------------------------------------------------------------------*
49559 :h3. CER decoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,
49560 .*---------------------------------------------------------------------*
49563 <TC - CER decoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,>
49581 BERPDU ::= [0] CHOICE
49594 import from TempA all;
49596 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49598 const BERPDU myValue := {b := true }
49604 if (dec_BER_PDU('A0808301FF0000'O) == myValue)
49607 {setverdict(pass);} else {setverdict(fail);}
49612 Overall verdict: pass
49618 .*---------------------------------------------------------------------*
49619 :h3. DER decoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,
49620 .*---------------------------------------------------------------------*
49623 <TC - DER decoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,>
49641 BERPDU ::= [0] CHOICE
49654 import from TempA all;
49656 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49658 const BERPDU myValue := {b := true }
49664 if (dec_BER_PDU('A005A3030101FF'O) == myValue)
49667 {setverdict(pass);} else {setverdict(fail);}
49672 Overall verdict: pass
49678 .*---------------------------------------------------------------------*
49679 :h3. CER decoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,
49680 .*---------------------------------------------------------------------*
49683 <TC - CER decoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,>
49701 BERPDU ::= [0] CHOICE
49714 import from TempA all;
49716 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49718 const BERPDU myValue := {b := true }
49724 if (dec_BER_PDU('A080A3800101FF00000000'O) == myValue)
49727 {setverdict(pass);} else {setverdict(fail);}
49732 Overall verdict: pass
49738 .*---------------------------------------------------------------------*
49739 :h3. DER decoding of CHOICE, NO DEFAULT, TAGGED CHOICE,
49740 .*---------------------------------------------------------------------*
49743 <TC - DER decoding of CHOICE, NO DEFAULT, TAGGED CHOICE,>
49760 BERPDU ::= [0] CHOICE
49773 import from TempA all;
49775 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49777 const BERPDU myValue := {b := true }
49783 if (dec_BER_PDU('A005A3030101FF'O) == myValue)
49786 {setverdict(pass);} else {setverdict(fail);}
49791 Overall verdict: pass
49797 .*---------------------------------------------------------------------*
49798 :h3. CER decoding of CHOICE, NO DEFAULT, TAGGED CHOICE,
49799 .*---------------------------------------------------------------------*
49802 <TC - CER decoding of CHOICE, NO DEFAULT, TAGGED CHOICE,>
49819 BERPDU ::= [0] CHOICE
49832 import from TempA all;
49834 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49836 const BERPDU myValue := {b := true }
49842 if (dec_BER_PDU('A080A3800101FF00000000'O) == myValue)
49845 {setverdict(pass);} else {setverdict(fail);}
49850 Overall verdict: pass
49856 .*---------------------------------------------------------------------*
49857 :h3. DER decoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,
49858 .*---------------------------------------------------------------------*
49861 <TC - DER decoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,>
49879 BERPDU ::= [0] CHOICE
49892 import from TempA all;
49894 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49896 const BERPDU myValue := {b := true }
49902 if (dec_BER_PDU('A0038301FF'O) == myValue)
49905 {setverdict(pass);} else {setverdict(fail);}
49910 Overall verdict: pass
49916 .*---------------------------------------------------------------------*
49917 :h3. CER decoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,
49918 .*---------------------------------------------------------------------*
49921 <TC - CER decoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,>
49939 BERPDU ::= [0] CHOICE
49952 import from TempA all;
49954 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49956 const BERPDU myValue := {b := true }
49962 if (dec_BER_PDU('A0808301FF0000'O) == myValue)
49965 {setverdict(pass);} else {setverdict(fail);}
49970 Overall verdict: pass
49976 .*---------------------------------------------------------------------*
49977 :h3.CER + DER encoding of OBJECT IDENTIFIER , itu-t(0) recommendation(0) (primitive)
49978 .*---------------------------------------------------------------------*
49981 <TC - CER + DER encoding of OBJECT IDENTIFIER , itu-t(0) recommendation(0) (primitive)>
49989 BERPDU ::= OBJECT IDENTIFIER
49990 b BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)}
49996 import from TempA all;
49997 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
49998 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50004 if ((enc_DER_PDU(b) == '0603000203'O)and(enc_CER_PDU(b) == '0603000203'O)) {setverdict(pass);} else {setverdict(fail);}
50008 Overall verdict: pass
50014 .*---------------------------------------------------------------------*
50015 :h3.CER + DER encoding of OBJECT IDENTIFIER , itu-t recommendation (primitive)
50016 .*---------------------------------------------------------------------*
50019 <TC - CER + DER encoding of OBJECT IDENTIFIER , itu-t recommendation (primitive)>
50027 BERPDU ::= OBJECT IDENTIFIER
50028 b BERPDU ::= {itu-t recommendation a(2) b(3)}
50034 import from TempA all;
50035 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50036 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50042 if ((enc_DER_PDU(b) == '0603000203'O)and(enc_CER_PDU(b) == '0603000203'O)) {setverdict(pass);} else {setverdict(fail);}
50046 Overall verdict: pass
50052 .*---------------------------------------------------------------------*
50053 :h3.CER + DER encoding of OBJECT IDENTIFIER , 0 0 (primitive)
50054 .*---------------------------------------------------------------------*
50057 <TC - CER + DER encoding of OBJECT IDENTIFIER , 0 0 (primitive)>
50065 BERPDU ::= OBJECT IDENTIFIER
50066 b BERPDU ::= {0 0 a(2) b(3)}
50072 import from TempA all;
50073 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50074 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50080 if ((enc_DER_PDU(b) == '0603000203'O)and(enc_CER_PDU(b) == '0603000203'O)) {setverdict(pass);} else {setverdict(fail);}
50084 Overall verdict: pass
50090 .*---------------------------------------------------------------------*
50091 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) question(1),(primitive)
50092 .*---------------------------------------------------------------------*
50095 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) question(1),(primitive)>
50103 BERPDU ::= OBJECT IDENTIFIER
50104 b BERPDU ::= {itu-t(0) question(1) a(2) b(3)}
50110 import from TempA all;
50111 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50112 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50118 if ((enc_DER_PDU(b) == '0603010203'O)and(enc_CER_PDU(b) == '0603010203'O)) {setverdict(pass);} else {setverdict(fail);}
50122 Overall verdict: pass
50128 .*---------------------------------------------------------------------*
50129 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t question,(primitive)
50130 .*---------------------------------------------------------------------*
50133 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t question,(primitive)>
50141 BERPDU ::= OBJECT IDENTIFIER
50142 b BERPDU ::= {itu-t question a(2) b(3)}
50148 import from TempA all;
50149 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50150 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50156 if ((enc_DER_PDU(b) == '0603010203'O)and(enc_CER_PDU(b) == '0603010203'O)) {setverdict(pass);} else {setverdict(fail);}
50160 Overall verdict: pass
50166 .*---------------------------------------------------------------------*
50167 :h3.CER + DER encoding of OBJECT IDENTIFIER ,0 1,(primitive)
50168 .*---------------------------------------------------------------------*
50171 <TC - CER + DER encoding of OBJECT IDENTIFIER ,0 1,(primitive)>
50179 BERPDU ::= OBJECT IDENTIFIER
50180 b BERPDU ::= {0 1 a(2) b(3)}
50186 import from TempA all;
50187 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50188 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50194 if ((enc_DER_PDU(b) == '0603010203'O)and(enc_CER_PDU(b) == '0603010203'O)) {setverdict(pass);} else {setverdict(fail);}
50198 Overall verdict: pass
50204 .*---------------------------------------------------------------------*
50205 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) administration(2),(primitive)
50206 .*---------------------------------------------------------------------*
50209 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) administration(2),(primitive)>
50217 BERPDU ::= OBJECT IDENTIFIER
50218 b BERPDU ::= {itu-t(0) administration(2) a(2) b(3)}
50224 import from TempA all;
50225 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50226 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50232 if ((enc_DER_PDU(b) == '0603020203'O)and(enc_CER_PDU(b) == '0603020203'O)) {setverdict(pass);} else {setverdict(fail);}
50236 Overall verdict: pass
50242 .*---------------------------------------------------------------------*
50243 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t administration,(primitive)
50244 .*---------------------------------------------------------------------*
50247 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t administration,(primitive)>
50255 BERPDU ::= OBJECT IDENTIFIER
50256 b BERPDU ::= {itu-t administration a(2) b(3)}
50262 import from TempA all;
50263 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50264 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50270 if ((enc_DER_PDU(b) == '0603020203'O)and(enc_CER_PDU(b) == '0603020203'O)) {setverdict(pass);} else {setverdict(fail);}
50274 Overall verdict: pass
50280 .*---------------------------------------------------------------------*
50281 :h3.CER + DER encoding of OBJECT IDENTIFIER ,0 2,(primitive)
50282 .*---------------------------------------------------------------------*
50285 <TC - CER + DER encoding of OBJECT IDENTIFIER ,0 2,(primitive)>
50293 BERPDU ::= OBJECT IDENTIFIER
50294 b BERPDU ::= {0 2 a(2) b(3)}
50300 import from TempA all;
50301 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50302 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50308 if ((enc_DER_PDU(b) == '0603020203'O)and(enc_CER_PDU(b) == '0603020203'O)) {setverdict(pass);} else {setverdict(fail);}
50312 Overall verdict: pass
50318 .*---------------------------------------------------------------------*
50319 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) network-operator(3),(primitive)
50320 .*---------------------------------------------------------------------*
50323 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) network-operator(3),(primitive)>
50331 BERPDU ::= OBJECT IDENTIFIER
50332 b BERPDU ::= {itu-t(0) network-operator(3) a(2) b(3)}
50338 import from TempA all;
50339 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50340 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50346 if ((enc_DER_PDU(b) == '0603030203'O)and(enc_CER_PDU(b) == '0603030203'O)) {setverdict(pass);} else {setverdict(fail);}
50350 Overall verdict: pass
50356 .*---------------------------------------------------------------------*
50357 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t network-operator,(primitive)
50358 .*---------------------------------------------------------------------*
50361 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t network-operator,(primitive)>
50369 BERPDU ::= OBJECT IDENTIFIER
50370 b BERPDU ::= {itu-t network-operator a(2) b(3)}
50376 import from TempA all;
50377 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50378 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50384 if ((enc_DER_PDU(b) == '0603030203'O)and(enc_CER_PDU(b) == '0603030203'O)) {setverdict(pass);} else {setverdict(fail);}
50388 Overall verdict: pass
50394 .*---------------------------------------------------------------------*
50395 :h3.CER + DER encoding of OBJECT IDENTIFIER ,0 3,(primitive)
50396 .*---------------------------------------------------------------------*
50399 <TC - CER + DER encoding of OBJECT IDENTIFIER ,0 3,(primitive)>
50407 BERPDU ::= OBJECT IDENTIFIER
50408 b BERPDU ::= {0 3 a(2) b(3)}
50414 import from TempA all;
50415 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50416 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50422 if ((enc_DER_PDU(b) == '0603030203'O)and(enc_CER_PDU(b) == '0603030203'O)) {setverdict(pass);} else {setverdict(fail);}
50426 Overall verdict: pass
50432 .*---------------------------------------------------------------------*
50433 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) identified-organization(4),(primitive)
50434 .*---------------------------------------------------------------------*
50437 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) identified-organization(4),(primitive)>
50445 BERPDU ::= OBJECT IDENTIFIER
50446 b BERPDU ::= {itu-t(0) identified-organization(4) a(2) b(3)}
50452 import from TempA all;
50453 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50454 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50460 if ((enc_DER_PDU(b) == '0603040203'O)and(enc_CER_PDU(b) == '0603040203'O)) {setverdict(pass);} else {setverdict(fail);}
50464 Overall verdict: pass
50470 .*---------------------------------------------------------------------*
50471 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t identified-organization,(primitive)
50472 .*---------------------------------------------------------------------*
50475 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t identified-organization,(primitive)>
50483 BERPDU ::= OBJECT IDENTIFIER
50484 b BERPDU ::= {itu-t identified-organization a(2) b(3)}
50490 import from TempA all;
50491 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50492 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50498 if ((enc_DER_PDU(b) == '0603040203'O)and(enc_CER_PDU(b) == '0603040203'O)) {setverdict(pass);} else {setverdict(fail);}
50502 Overall verdict: pass
50508 .*---------------------------------------------------------------------*
50509 :h3.CER + DER encoding of OBJECT IDENTIFIER ,0 4,(primitive)
50510 .*---------------------------------------------------------------------*
50513 <TC - CER + DER encoding of OBJECT IDENTIFIER ,0 4,(primitive)>
50521 BERPDU ::= OBJECT IDENTIFIER
50522 b BERPDU ::= {0 4 a(2) b(3)}
50528 import from TempA all;
50529 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50530 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50536 if ((enc_DER_PDU(b) == '0603040203'O)and(enc_CER_PDU(b) == '0603040203'O)) {setverdict(pass);} else {setverdict(fail);}
50540 Overall verdict: pass
50546 .*---------------------------------------------------------------------*
50547 :h3.CER + DER encoding of OBJECT IDENTIFIER , iso(1) standard(0) (primitive)
50548 .*---------------------------------------------------------------------*
50551 <TC - CER + DER encoding of OBJECT IDENTIFIER , iso(1) standard(0) (primitive)>
50559 BERPDU ::= OBJECT IDENTIFIER
50560 b BERPDU ::= {iso(1) standard(0) a(2) b(3)}
50566 import from TempA all;
50567 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50568 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50574 if ((enc_DER_PDU(b) == '0603280203'O)and(enc_CER_PDU(b) == '0603280203'O)) {setverdict(pass);} else {setverdict(fail);}
50578 Overall verdict: pass
50584 .*---------------------------------------------------------------------*
50585 :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso standard (primitive)
50586 .*---------------------------------------------------------------------*
50589 <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso standard (primitive)>
50597 BERPDU ::= OBJECT IDENTIFIER
50598 b BERPDU ::= {iso standard a(2) b(3)}
50604 import from TempA all;
50605 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50606 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50612 if ((enc_DER_PDU(b) == '0603280203'O)and(enc_CER_PDU(b) == '0603280203'O)) {setverdict(pass);} else {setverdict(fail);}
50616 Overall verdict: pass
50622 .*---------------------------------------------------------------------*
50623 :h3.CER + DER encoding of OBJECT IDENTIFIER , 1 0 (primitive)
50624 .*---------------------------------------------------------------------*
50627 <TC - CER + DER encoding of OBJECT IDENTIFIER , 1 0 (primitive)>
50635 BERPDU ::= OBJECT IDENTIFIER
50636 b BERPDU ::= {1 0 a(2) b(3)}
50642 import from TempA all;
50643 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50644 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50650 if ((enc_DER_PDU(b) == '0603280203'O)and(enc_CER_PDU(b) == '0603280203'O)) {setverdict(pass);} else {setverdict(fail);}
50654 Overall verdict: pass
50660 .*---------------------------------------------------------------------*
50661 :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso(1) member-body(2)(primitive)
50662 .*---------------------------------------------------------------------*
50665 <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso(1) member-body(2)(primitive)>
50673 BERPDU ::= OBJECT IDENTIFIER
50674 b BERPDU ::= {iso(1) member-body(2) a(2) b(3)}
50680 import from TempA all;
50681 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50682 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50688 if ((enc_DER_PDU(b) == '06032A0203'O)and(enc_CER_PDU(b) == '06032A0203'O)) {setverdict(pass);} else {setverdict(fail);}
50692 Overall verdict: pass
50698 .*---------------------------------------------------------------------*
50699 :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso member-body(primitive)
50700 .*---------------------------------------------------------------------*
50703 <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso member-body(primitive)>
50711 BERPDU ::= OBJECT IDENTIFIER
50712 b BERPDU ::= {iso member-body a(2) b(3)}
50718 import from TempA all;
50719 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50720 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50726 if ((enc_DER_PDU(b) == '06032A0203'O)and(enc_CER_PDU(b) == '06032A0203'O)) {setverdict(pass);} else {setverdict(fail);}
50730 Overall verdict: pass
50736 .*---------------------------------------------------------------------*
50737 :h3.CER + DER encoding of OBJECT IDENTIFIER , 1 2 (primitive)
50738 .*---------------------------------------------------------------------*
50741 <TC - CER + DER encoding of OBJECT IDENTIFIER , 1 2 (primitive)>
50749 BERPDU ::= OBJECT IDENTIFIER
50750 b BERPDU ::= {1 2 a(2) b(3)}
50756 import from TempA all;
50757 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50758 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50764 if ((enc_DER_PDU(b) == '06032A0203'O)and(enc_CER_PDU(b) == '06032A0203'O)) {setverdict(pass);} else {setverdict(fail);}
50768 Overall verdict: pass
50774 .*---------------------------------------------------------------------*
50775 :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso(1) identified-organization(3) (primitive)
50776 .*---------------------------------------------------------------------*
50779 <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso(1) identified-organization(3) (primitive)>
50787 BERPDU ::= OBJECT IDENTIFIER
50788 b BERPDU ::= {iso(1) identified-organization(3) a(2) b(3)}
50794 import from TempA all;
50795 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50796 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50802 if ((enc_DER_PDU(b) == '06032B0203'O)and(enc_CER_PDU(b) == '06032B0203'O)) {setverdict(pass);} else {setverdict(fail);}
50806 Overall verdict: pass
50812 .*---------------------------------------------------------------------*
50813 :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso identified-organization(primitive)
50814 .*---------------------------------------------------------------------*
50817 <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso identified-organization(primitive)>
50825 BERPDU ::= OBJECT IDENTIFIER
50826 b BERPDU ::= {iso identified-organization a(2) b(3)}
50832 import from TempA all;
50833 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50834 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50840 if ((enc_DER_PDU(b) == '06032B0203'O)and(enc_CER_PDU(b) == '06032B0203'O)) {setverdict(pass);} else {setverdict(fail);}
50844 Overall verdict: pass
50850 .*---------------------------------------------------------------------*
50851 :h3.CER + DER encoding of OBJECT IDENTIFIER , 1 3 (primitive)
50852 .*---------------------------------------------------------------------*
50855 <TC - CER + DER encoding of OBJECT IDENTIFIER , 1 3 (primitive)>
50863 BERPDU ::= OBJECT IDENTIFIER
50864 b BERPDU ::= {1 3 a(2) b(3)}
50870 import from TempA all;
50871 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50872 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50878 if ((enc_DER_PDU(b) == '06032B0203'O)and(enc_CER_PDU(b) == '06032B0203'O)) {setverdict(pass);} else {setverdict(fail);}
50882 Overall verdict: pass
50888 .*---------------------------------------------------------------------*
50889 :h3.CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t(2) something(0)(primitive)
50890 .*---------------------------------------------------------------------*
50893 <TC - CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t(2) something(0)(primitive)>
50901 BERPDU ::= OBJECT IDENTIFIER
50902 b BERPDU ::= {joint-iso-itu-t(2) something(0) a(2) b(3)}
50908 import from TempA all;
50909 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50910 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50916 if ((enc_DER_PDU(b) == '0603500203'O)and(enc_CER_PDU(b) == '0603500203'O)) {setverdict(pass);} else {setverdict(fail);}
50920 Overall verdict: pass
50926 .*---------------------------------------------------------------------*
50927 :h3.CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t something(0) (primitive)
50928 .*---------------------------------------------------------------------*
50931 <TC - CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t something(0) (primitive)>
50939 BERPDU ::= OBJECT IDENTIFIER
50940 b BERPDU ::= {joint-iso-itu-t something(0) a(2) b(3)}
50946 import from TempA all;
50947 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50948 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50954 if ((enc_DER_PDU(b) == '0603500203'O)and(enc_CER_PDU(b) == '0603500203'O)) {setverdict(pass);} else {setverdict(fail);}
50958 Overall verdict: pass
50964 .*---------------------------------------------------------------------*
50965 :h3.CER + DER encoding of OBJECT IDENTIFIER , 2 0 (primitive)
50966 .*---------------------------------------------------------------------*
50969 <TC - CER + DER encoding of OBJECT IDENTIFIER , 2 0 (primitive)>
50977 BERPDU ::= OBJECT IDENTIFIER
50978 b BERPDU ::= {2 0 a(2) b(3)}
50984 import from TempA all;
50985 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50986 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50992 if ((enc_DER_PDU(b) == '0603500203'O)and(enc_CER_PDU(b) == '0603500203'O)) {setverdict(pass);} else {setverdict(fail);}
50996 Overall verdict: pass
51002 .*---------------------------------------------------------------------*
51003 :h3.CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t(2) something(100) (primitive)
51004 .*---------------------------------------------------------------------*
51007 <TC - CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t(2) something(100) (primitive)>
51015 BERPDU ::= OBJECT IDENTIFIER
51016 b BERPDU ::= {joint-iso-itu-t(2) something(100) a(2) b(3)}
51022 import from TempA all;
51023 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
51024 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
51030 if ((enc_DER_PDU(b) == '060481340203'O)and(enc_CER_PDU(b) == '060481340203'O)) {setverdict(pass);} else {setverdict(fail);}
51034 Overall verdict: pass
51040 .*---------------------------------------------------------------------*
51041 :h3.CER + DER encoding of OBJECT IDENTIFIER ,joint-iso-itu-t 100 (primitive)
51042 .*---------------------------------------------------------------------*
51045 <TC - CER + DER encoding of OBJECT IDENTIFIER ,joint-iso-itu-t 100 (primitive)>
51053 BERPDU ::= OBJECT IDENTIFIER
51054 b BERPDU ::= {joint-iso-itu-t 100 a(2) b(3)}
51060 import from TempA all;
51061 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
51062 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
51068 if ((enc_DER_PDU(b) == '060481340203'O)and(enc_CER_PDU(b) == '060481340203'O)) {setverdict(pass);} else {setverdict(fail);}
51072 Overall verdict: pass
51078 .*---------------------------------------------------------------------*
51079 :h3.CER + DER encoding of OBJECT IDENTIFIER , 2 100 (primitive)
51080 .*---------------------------------------------------------------------*
51083 <TC - CER + DER encoding of OBJECT IDENTIFIER , 2 100 (primitive)>
51091 BERPDU ::= OBJECT IDENTIFIER
51092 b BERPDU ::= {2 100 a(2) b(3)}
51098 import from TempA all;
51099 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
51100 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
51106 if ((enc_DER_PDU(b) == '060481340203'O)and(enc_CER_PDU(b) == '060481340203'O)) {setverdict(pass);} else {setverdict(fail);}
51110 Overall verdict: pass
51116 .*---------------------------------------------------------------------*
51117 :h3.CER + DER encoding of OBJECT IDENTIFIER , multiple octets needed for values (primitive)
51118 .*---------------------------------------------------------------------*
51121 <TC - CER + DER encoding of OBJECT IDENTIFIER , multiple octets needed for values (primitive)>
51129 BERPDU ::= OBJECT IDENTIFIER
51130 b BERPDU ::= {joint-iso-itu-t(2) something(0) a(2) b(3) 2000 4000 }
51136 import from TempA all;
51137 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
51138 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
51144 if ((enc_DER_PDU(b) == '06075002038F509F20'O)and(enc_CER_PDU(b) == '06075002038F509F20'O)) {setverdict(pass);} else {setverdict(fail);}
51148 Overall verdict: pass
51154 .*---------------------------------------------------------------------*
51155 :h3.CER + DER encoding of OBJECT IDENTIFIER , [0] IMPLICIT, primitive
51156 .*---------------------------------------------------------------------*
51159 <TC - CER + DER encoding of OBJECT IDENTIFIER , [0] IMPLICIT, primitive>
51167 BERPDU ::= [0] IMPLICIT OBJECT IDENTIFIER
51168 b BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)}
51174 import from TempA all;
51175 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
51176 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
51182 if ((enc_DER_PDU(b) == '8003000203'O)and(enc_CER_PDU(b) == '8003000203'O)) {setverdict(pass);} else {setverdict(fail);}
51186 Overall verdict: pass
51192 .*---------------------------------------------------------------------*
51193 :h3.CER + DER encoding of OBJECT IDENTIFIER , [0] EXPLICIT constructed
51194 .*---------------------------------------------------------------------*
51197 <TC - CER + DER encoding of OBJECT IDENTIFIER , [0] EXPLICIT constructed>
51205 BERPDU ::= [0] EXPLICIT OBJECT IDENTIFIER
51206 b BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)}
51212 import from TempA all;
51213 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
51214 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
51220 if ((enc_DER_PDU(b) == 'A0050603000203'O)and(enc_CER_PDU(b) == 'A08006030002030000'O)) {setverdict(pass);} else {setverdict(fail);}
51224 Overall verdict: pass
51230 .*---------------------------------------------------------------------*
51231 :h3. DECODING OBJECT IDENTIFIER , CER+DER, itu-t(0) recommendation(0) ,(primitive)
51232 .*---------------------------------------------------------------------*
51235 <TC - DECODING OBJECT IDENTIFIER , CER+DER, itu-t(0) recommendation(0) ,(primitive)>
51243 BERPDU ::= OBJECT IDENTIFIER
51245 myValue BERPDU ::= { itu-t(0) recommendation(0) a(2) b(3)}
51251 import from TempA all;
51253 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51258 if (dec_BER_PDU('0603000203'O) == myValue)
51261 {setverdict(pass);} else {setverdict(fail);}
51266 Overall verdict: pass
51272 .*---------------------------------------------------------------------*
51273 :h3. DECODING OBJECT IDENTIFIER , CER+DER, itu-t recommendation ,(primitive)
51274 .*---------------------------------------------------------------------*
51277 <TC - DECODING OBJECT IDENTIFIER , CER+DER, itu-t recommendation ,(primitive)>
51285 BERPDU ::= OBJECT IDENTIFIER
51287 myValue BERPDU ::= {itu-t recommendation a(2) b(3)}
51293 import from TempA all;
51295 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51300 if (dec_BER_PDU('0603000203'O) == myValue)
51303 {setverdict(pass);} else {setverdict(fail);}
51308 Overall verdict: pass
51314 .*---------------------------------------------------------------------*
51315 :h3. DECODING OBJECT IDENTIFIER , CER+DER 0 0 ,(primitive)
51316 .*---------------------------------------------------------------------*
51319 <TC - DECODING OBJECT IDENTIFIER , CER+DER 0 0 ,(primitive)>
51327 BERPDU ::= OBJECT IDENTIFIER
51329 myValue BERPDU ::= {0 0 a(2) b(3)}
51335 import from TempA all;
51337 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51342 if (dec_BER_PDU('0603000203'O) == myValue)
51345 {setverdict(pass);} else {setverdict(fail);}
51350 Overall verdict: pass
51356 .*---------------------------------------------------------------------*
51357 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) question(1) ,(primitive)
51358 .*---------------------------------------------------------------------*
51361 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) question(1) ,(primitive)>
51369 BERPDU ::= OBJECT IDENTIFIER
51371 myValue BERPDU ::= {itu-t(0) question(1) a(2) b(3)}
51377 import from TempA all;
51379 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51384 if (dec_BER_PDU('0603010203'O) == myValue)
51387 {setverdict(pass);} else {setverdict(fail);}
51392 Overall verdict: pass
51398 .*---------------------------------------------------------------------*
51399 :h3. DECODING OBJECT IDENTIFIER , CER+DER, itu-t question ,(primitive)
51400 .*---------------------------------------------------------------------*
51403 <TC - DECODING OBJECT IDENTIFIER , CER+DER, itu-t question ,(primitive)>
51411 BERPDU ::= OBJECT IDENTIFIER
51413 myValue BERPDU ::= {itu-t question a(2) b(3)}
51419 import from TempA all;
51421 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51426 if (dec_BER_PDU('0603010203'O) == myValue)
51429 {setverdict(pass);} else {setverdict(fail);}
51434 Overall verdict: pass
51440 .*---------------------------------------------------------------------*
51441 :h3. DECODING OBJECT IDENTIFIER , CER+DER 0 1 ,(primitive)
51442 .*---------------------------------------------------------------------*
51445 <TC - DECODING OBJECT IDENTIFIER , CER+DER 0 1 ,(primitive)>
51453 BERPDU ::= OBJECT IDENTIFIER
51455 myValue BERPDU ::= {0 1 a(2) b(3)}
51461 import from TempA all;
51463 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51468 if (dec_BER_PDU('0603010203'O) == myValue)
51471 {setverdict(pass);} else {setverdict(fail);}
51476 Overall verdict: pass
51482 .*---------------------------------------------------------------------*
51483 :h3. DECODING OBJECT IDENTIFIER , CER+DER , itu-t(0) administration(2) ,(primitive)
51484 .*---------------------------------------------------------------------*
51487 <TC - DECODING OBJECT IDENTIFIER , CER+DER , itu-t(0) administration(2) ,(primitive)>
51495 BERPDU ::= OBJECT IDENTIFIER
51497 myValue BERPDU ::= {itu-t(0) administration(2) a(2) b(3)}
51503 import from TempA all;
51505 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51510 if (dec_BER_PDU('0603020203'O) == myValue)
51513 {setverdict(pass);} else {setverdict(fail);}
51518 Overall verdict: pass
51524 .*---------------------------------------------------------------------*
51525 :h3. DECODING OBJECT IDENTIFIER , CER+DER , itu-t administration ,(primitive)
51526 .*---------------------------------------------------------------------*
51529 <TC - DECODING OBJECT IDENTIFIER , CER+DER , itu-t administration ,(primitive)>
51537 BERPDU ::= OBJECT IDENTIFIER
51539 myValue BERPDU ::= {itu-t administration a(2) b(3)}
51545 import from TempA all;
51547 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51552 if (dec_BER_PDU('0603020203'O) == myValue)
51555 {setverdict(pass);} else {setverdict(fail);}
51560 Overall verdict: pass
51566 .*---------------------------------------------------------------------*
51567 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,0 2 ,(primitive)
51568 .*---------------------------------------------------------------------*
51571 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,0 2 ,(primitive)>
51579 BERPDU ::= OBJECT IDENTIFIER
51581 myValue BERPDU ::= {0 2 a(2) b(3)}
51587 import from TempA all;
51589 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51594 if (dec_BER_PDU('0603020203'O) == myValue)
51597 {setverdict(pass);} else {setverdict(fail);}
51602 Overall verdict: pass
51608 .*---------------------------------------------------------------------*
51609 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) network-operator(3) ,(primitive)
51610 .*---------------------------------------------------------------------*
51613 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) network-operator(3) ,(primitive)>
51621 BERPDU ::= OBJECT IDENTIFIER
51623 myValue BERPDU ::= {itu-t(0) network-operator(3) a(2) b(3)}
51629 import from TempA all;
51631 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51636 if (dec_BER_PDU('0603030203'O) == myValue)
51639 {setverdict(pass);} else {setverdict(fail);}
51644 Overall verdict: pass
51650 .*---------------------------------------------------------------------*
51651 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t network-operator ,(primitive)
51652 .*---------------------------------------------------------------------*
51655 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t network-operator ,(primitive)>
51663 BERPDU ::= OBJECT IDENTIFIER
51665 myValue BERPDU ::= {itu-t network-operator a(2) b(3)}
51671 import from TempA all;
51673 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51678 if (dec_BER_PDU('0603030203'O) == myValue)
51681 {setverdict(pass);} else {setverdict(fail);}
51686 Overall verdict: pass
51692 .*---------------------------------------------------------------------*
51693 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,0 3 ,(primitive)
51694 .*---------------------------------------------------------------------*
51697 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,0 3 ,(primitive)>
51705 BERPDU ::= OBJECT IDENTIFIER
51707 myValue BERPDU ::= {0 3 a(2) b(3)}
51713 import from TempA all;
51715 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51720 if (dec_BER_PDU('0603030203'O) == myValue)
51723 {setverdict(pass);} else {setverdict(fail);}
51728 Overall verdict: pass
51734 .*---------------------------------------------------------------------*
51735 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) identified-organization(4) ,(primitive)
51736 .*---------------------------------------------------------------------*
51739 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) identified-organization(4) ,(primitive)>
51747 BERPDU ::= OBJECT IDENTIFIER
51749 myValue BERPDU ::= {itu-t(0) identified-organization(4) a(2) b(3)}
51755 import from TempA all;
51757 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51762 if (dec_BER_PDU('0603040203'O) == myValue)
51765 {setverdict(pass);} else {setverdict(fail);}
51770 Overall verdict: pass
51776 .*---------------------------------------------------------------------*
51777 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t identified-organization ,(primitive)
51778 .*---------------------------------------------------------------------*
51781 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t identified-organization ,(primitive)>
51789 BERPDU ::= OBJECT IDENTIFIER
51791 myValue BERPDU ::= {itu-t identified-organization a(2) b(3)}
51797 import from TempA all;
51799 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51804 if (dec_BER_PDU('0603040203'O) == myValue)
51807 {setverdict(pass);} else {setverdict(fail);}
51812 Overall verdict: pass
51818 .*---------------------------------------------------------------------*
51819 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,0 4 ,(primitive)
51820 .*---------------------------------------------------------------------*
51823 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,0 4 ,(primitive)>
51831 BERPDU ::= OBJECT IDENTIFIER
51833 myValue BERPDU ::= {0 4 a(2) b(3)}
51839 import from TempA all;
51841 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51846 if (dec_BER_PDU('0603040203'O) == myValue)
51849 {setverdict(pass);} else {setverdict(fail);}
51854 Overall verdict: pass
51860 .*---------------------------------------------------------------------*
51861 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) standard(0) ,(primitive)
51862 .*---------------------------------------------------------------------*
51865 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) standard(0) ,(primitive)>
51873 BERPDU ::= OBJECT IDENTIFIER
51875 myValue BERPDU ::= {iso(1) standard(0) a(2) b(3)}
51881 import from TempA all;
51883 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51888 if (dec_BER_PDU('0603280203'O) == myValue)
51891 {setverdict(pass);} else {setverdict(fail);}
51896 Overall verdict: pass
51902 .*---------------------------------------------------------------------*
51903 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso standard ,(primitive)
51904 .*---------------------------------------------------------------------*
51907 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso standard ,(primitive)>
51915 BERPDU ::= OBJECT IDENTIFIER
51917 myValue BERPDU ::= {iso standard a(2) b(3)}
51923 import from TempA all;
51925 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51930 if (dec_BER_PDU('0603280203'O) == myValue)
51933 {setverdict(pass);} else {setverdict(fail);}
51938 Overall verdict: pass
51944 .*---------------------------------------------------------------------*
51945 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,1 0 ,(primitive)
51946 .*---------------------------------------------------------------------*
51949 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,1 0 ,(primitive)>
51957 BERPDU ::= OBJECT IDENTIFIER
51959 myValue BERPDU ::= {1 0 a(2) b(3)}
51965 import from TempA all;
51967 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51972 if (dec_BER_PDU('0603280203'O) == myValue)
51975 {setverdict(pass);} else {setverdict(fail);}
51980 Overall verdict: pass
51986 .*---------------------------------------------------------------------*
51987 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) member-body(2) ,(primitive)
51988 .*---------------------------------------------------------------------*
51991 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) member-body(2) ,(primitive)>
51999 BERPDU ::= OBJECT IDENTIFIER
52001 myValue BERPDU ::= {iso(1) member-body(2) a(2) b(3)}
52007 import from TempA all;
52009 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52014 if (dec_BER_PDU('06032A0203'O) == myValue)
52017 {setverdict(pass);} else {setverdict(fail);}
52022 Overall verdict: pass
52028 .*---------------------------------------------------------------------*
52029 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso member-body ,(primitive)
52030 .*---------------------------------------------------------------------*
52033 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso member-body ,(primitive)>
52041 BERPDU ::= OBJECT IDENTIFIER
52043 myValue BERPDU ::= {iso member-body a(2) b(3)}
52049 import from TempA all;
52051 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52056 if (dec_BER_PDU('06032A0203'O) == myValue)
52059 {setverdict(pass);} else {setverdict(fail);}
52064 Overall verdict: pass
52070 .*---------------------------------------------------------------------*
52071 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,1 2 ,(primitive)
52072 .*---------------------------------------------------------------------*
52075 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,1 2 ,(primitive)>
52083 BERPDU ::= OBJECT IDENTIFIER
52085 myValue BERPDU ::= {1 2 a(2) b(3)}
52091 import from TempA all;
52093 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52098 if (dec_BER_PDU('06032A0203'O) == myValue)
52101 {setverdict(pass);} else {setverdict(fail);}
52106 Overall verdict: pass
52112 .*---------------------------------------------------------------------*
52113 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) identified-organization(3) ,(primitive)
52114 .*---------------------------------------------------------------------*
52117 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) identified-organization(3) ,(primitive)>
52125 BERPDU ::= OBJECT IDENTIFIER
52127 myValue BERPDU ::= {iso(1) identified-organization(3) a(2) b(3)}
52133 import from TempA all;
52135 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52140 if (dec_BER_PDU('06032B0203'O) == myValue)
52143 {setverdict(pass);} else {setverdict(fail);}
52148 Overall verdict: pass
52154 .*---------------------------------------------------------------------*
52155 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso identified-organization ,(primitive)
52156 .*---------------------------------------------------------------------*
52159 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso identified-organization ,(primitive)>
52167 BERPDU ::= OBJECT IDENTIFIER
52169 myValue BERPDU ::= {iso identified-organization a(2) b(3)}
52175 import from TempA all;
52177 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52182 if (dec_BER_PDU('06032B0203'O) == myValue)
52185 {setverdict(pass);} else {setverdict(fail);}
52190 Overall verdict: pass
52196 .*---------------------------------------------------------------------*
52197 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,1 3 ,(primitive)
52198 .*---------------------------------------------------------------------*
52201 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,1 3 ,(primitive)>
52209 BERPDU ::= OBJECT IDENTIFIER
52211 myValue BERPDU ::= {1 3 a(2) b(3)}
52217 import from TempA all;
52219 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52224 if (dec_BER_PDU('06032B0203'O) == myValue)
52227 {setverdict(pass);} else {setverdict(fail);}
52232 Overall verdict: pass
52238 .*---------------------------------------------------------------------*
52239 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(0) ,(primitive)
52240 .*---------------------------------------------------------------------*
52243 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(0) ,(primitive)>
52251 BERPDU ::= OBJECT IDENTIFIER
52253 myValue BERPDU ::= {joint-iso-itu-t(2) something(0) a(2) b(3)}
52259 import from TempA all;
52261 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52266 if (dec_BER_PDU('0603500203'O) == myValue)
52269 {setverdict(pass);} else {setverdict(fail);}
52274 Overall verdict: pass
52280 .*---------------------------------------------------------------------*
52281 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t something(0) ,(primitive)
52282 .*---------------------------------------------------------------------*
52285 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t something(0) ,(primitive)>
52293 BERPDU ::= OBJECT IDENTIFIER
52295 myValue BERPDU ::= {joint-iso-itu-t something(0) a(2) b(3)}
52302 import from TempA all;
52304 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52309 if (dec_BER_PDU('0603500203'O) == myValue)
52312 {setverdict(pass);} else {setverdict(fail);}
52317 Overall verdict: pass
52323 .*---------------------------------------------------------------------*
52324 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,2 0 ,(primitive)
52325 .*---------------------------------------------------------------------*
52328 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,2 0 ,(primitive)>
52336 BERPDU ::= OBJECT IDENTIFIER
52338 myValue BERPDU ::= {2 0 a(2) b(3)}
52344 import from TempA all;
52346 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52351 if (dec_BER_PDU('0603500203'O) == myValue)
52354 {setverdict(pass);} else {setverdict(fail);}
52359 Overall verdict: pass
52365 .*---------------------------------------------------------------------*
52366 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(100) ,(primitive)
52367 .*---------------------------------------------------------------------*
52370 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(100) ,(primitive)>
52378 BERPDU ::= OBJECT IDENTIFIER
52380 myValue BERPDU ::= {joint-iso-itu-t(2) something(100) a(2) b(3)}
52386 import from TempA all;
52388 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52393 if (dec_BER_PDU('060481340203'O) == myValue)
52396 {setverdict(pass);} else {setverdict(fail);}
52401 Overall verdict: pass
52407 .*---------------------------------------------------------------------*
52408 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(100) ,(primitive)
52409 .*---------------------------------------------------------------------*
52412 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(100) ,(primitive)>
52420 BERPDU ::= OBJECT IDENTIFIER
52422 myValue BERPDU ::= {joint-iso-itu-t 100 a(2) b(3)}
52428 import from TempA all;
52430 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52435 if (dec_BER_PDU('060481340203'O) == myValue)
52438 {setverdict(pass);} else {setverdict(fail);}
52443 Overall verdict: pass
52449 .*---------------------------------------------------------------------*
52450 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,2 100 ,(primitive)
52451 .*---------------------------------------------------------------------*
52454 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,2 100 ,(primitive)>
52462 BERPDU ::= OBJECT IDENTIFIER
52464 myValue BERPDU ::= {2 100 a(2) b(3)}
52470 import from TempA all;
52472 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52477 if (dec_BER_PDU('060481340203'O) == myValue)
52480 {setverdict(pass);} else {setverdict(fail);}
52485 Overall verdict: pass
52491 .*---------------------------------------------------------------------*
52492 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,multiple octets needed for values ,(primitive)
52493 .*---------------------------------------------------------------------*
52496 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,multiple octets needed for values ,(primitive)>
52504 BERPDU ::= OBJECT IDENTIFIER
52506 myValue BERPDU ::= {joint-iso-itu-t(2) something(0) a(2) b(3) 2000 4000 }
52512 import from TempA all;
52514 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52519 if (dec_BER_PDU('06075002038F509F20'O) == myValue)
52522 {setverdict(pass);} else {setverdict(fail);}
52527 Overall verdict: pass
52533 .*---------------------------------------------------------------------*
52534 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,0 0, IMPLICIT, primitive
52535 .*---------------------------------------------------------------------*
52538 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,0 0, IMPLICIT, primitive>
52546 BERPDU ::= [0] IMPLICIT OBJECT IDENTIFIER
52548 myValue BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)}
52554 import from TempA all;
52556 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52561 if (dec_BER_PDU('8003000203'O) == myValue)
52564 {setverdict(pass);} else {setverdict(fail);}
52569 Overall verdict: pass
52575 .*---------------------------------------------------------------------*
52576 :h3. DECODING OBJECT IDENTIFIER , DER ,0 0, EXPLICIT, constructed
52577 .*---------------------------------------------------------------------*
52580 <TC - DECODING OBJECT IDENTIFIER , DER ,0 0, EXPLICIT, constructed>
52588 BERPDU ::= [0] EXPLICIT OBJECT IDENTIFIER
52590 myValue BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)}
52596 import from TempA all;
52598 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52603 if (dec_BER_PDU('A0050603000203'O) == myValue)
52607 {setverdict(pass);} else {setverdict(fail);}
52612 Overall verdict: pass
52618 .*---------------------------------------------------------------------*
52619 :h3. DECODING OBJECT IDENTIFIER , CER ,0 0, EXPLICIT, constructed
52620 .*---------------------------------------------------------------------*
52623 <TC - DECODING OBJECT IDENTIFIER , CER ,0 0, EXPLICIT, constructed>
52631 BERPDU ::= [0] EXPLICIT OBJECT IDENTIFIER
52633 myValue BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)}
52639 import from TempA all;
52641 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52646 if (dec_BER_PDU('A08006030002030000'O) == myValue)
52648 {setverdict(pass);} else {setverdict(fail);}
52653 Overall verdict: pass
52659 .*---------------------------------------------------------------------*
52660 :h3. CER + DER encoding of OPEN TYPE from Information Object Class
52661 .*---------------------------------------------------------------------*
52664 <TC - CER + DER encoding of OPEN TYPE from Information Object Class>
52674 --***************************************************************************************************
52675 --modified class taken from Gyuri ASN1
52676 --***************************************************************************************************
52677 MY-CLASS-1 ::= CLASS
52679 &TypeField OPTIONAL,
52680 &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL
52685 [TYPE FIELD &TypeField]
52686 [FIXED VALUE TYPE FIELD &fixedTypeValueField]
52689 ASN1-Type1 ::= INTEGER
52691 ASN1-Type2 ::= BOOLEAN
52693 ASN1-Type3 ::= SEQUENCE {f1 INTEGER}
52695 ASN1-Type4 ::= OCTET STRING
52698 --****************************************************************************************************
52699 -- OBJECTS using the class defined above
52700 --****************************************************************************************************
52703 myObject-1 MY-CLASS-1 ::=
52705 TYPE FIELD ASN1-Type3
52706 FIXED VALUE TYPE FIELD 999
52710 myObject-2 MY-CLASS-1 ::=
52712 TYPE FIELD ASN1-Type2
52713 FIXED VALUE TYPE FIELD 888
52716 myObject-3 MY-CLASS-1 ::=
52718 TYPE FIELD ASN1-Type4
52719 FIXED VALUE TYPE FIELD 555
52722 --****************************************************************************************************
52723 -- Defining Information Object sets
52724 --****************************************************************************************************
52726 MyInformationObjectSet1 MY-CLASS-1 ::=
52733 MyInformationObjectSet2 MY-CLASS-1 ::=
52735 MyInformationObjectSet1|
52740 BERPDU ::= SEQUENCE
52743 field1 MY-CLASS-1.&TypeField ({MyInformationObjectSet1} {@.field2} ),
52744 field2 MY-CLASS-1.&fixedTypeValueField ({MyInformationObjectSet1})
52752 import from TempA all;
52753 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
52754 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
52756 const BERPDU myValue := { field1 := {aSN1_Type3 := {f1 := 8}},field2 := 999 };
52761 if ((enc_DER_PDU(myValue) == '30093003020108020203E7'O)and(enc_CER_PDU(myValue) == '308030800201080000020203E70000'O)) {setverdict(pass);} else {setverdict(fail);}
52766 Overall verdict: pass
52772 .*---------------------------------------------------------------------*
52773 :h3. CER + DER encoding of TYPE from Information Object
52774 .*---------------------------------------------------------------------*
52777 <TC - CER + DER encoding of TYPE from Information Object >
52791 --***************************************************************************************************
52792 --modified class taken from Gyuri ASN1
52793 --***************************************************************************************************
52794 MY-CLASS-1 ::= CLASS
52796 &TypeField OPTIONAL,
52797 &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL
52802 [TYPE FIELD &TypeField]
52803 [FIXED VALUE TYPE FIELD &fixedTypeValueField]
52806 ASN1-Type1 ::= INTEGER
52808 ASN1-Type2 ::= BOOLEAN
52810 ASN1-Type3 ::= SEQUENCE {f1 INTEGER}
52812 ASN1-Type4 ::= OCTET STRING
52815 --****************************************************************************************************
52816 -- OBJECTS using the class defined above
52817 --****************************************************************************************************
52820 myObject-1 MY-CLASS-1 ::=
52822 TYPE FIELD ASN1-Type3
52823 FIXED VALUE TYPE FIELD 999
52827 myObject-2 MY-CLASS-1 ::=
52829 TYPE FIELD ASN1-Type2
52830 FIXED VALUE TYPE FIELD 888
52833 myObject-3 MY-CLASS-1 ::=
52835 TYPE FIELD ASN1-Type4
52836 FIXED VALUE TYPE FIELD 555
52839 --****************************************************************************************************
52840 -- Defining Information Object sets
52841 --****************************************************************************************************
52843 MyInformationObjectSet1 MY-CLASS-1 ::=
52850 MyInformationObjectSet2 MY-CLASS-1 ::=
52852 MyInformationObjectSet1|
52859 BERPDU ::= SEQUENCE
52862 field1 myObject-1.&TypeField , -- type from object
52863 field2 MY-CLASS-1.&fixedTypeValueField
52871 import from TempA all;
52872 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
52873 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
52875 const BERPDU myValue := { field1 := {f1 := 8},field2 := 999 };
52880 if ((enc_DER_PDU(myValue) == '30093003020108020203E7'O)and(enc_CER_PDU(myValue) == '308030800201080000020203E70000'O)) {setverdict(pass);} else {setverdict(fail);}
52885 Overall verdict: pass
52891 .*---------------------------------------------------------------------*
52892 :h3. DECODING ,OPEN TYPE, DER, from Information Object Class
52893 .*---------------------------------------------------------------------*
52896 <TC - DECODING ,OPEN TYPE, DER, from Information Object Class>
52907 --***************************************************************************************************
52908 --modified class taken from Gyuri ASN1
52909 --***************************************************************************************************
52910 MY-CLASS-1 ::= CLASS
52912 &TypeField OPTIONAL,
52913 &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL
52918 [TYPE FIELD &TypeField]
52919 [FIXED VALUE TYPE FIELD &fixedTypeValueField]
52922 ASN1-Type1 ::= INTEGER
52924 ASN1-Type2 ::= BOOLEAN
52926 ASN1-Type3 ::= SEQUENCE {f1 INTEGER}
52928 ASN1-Type4 ::= OCTET STRING
52931 --****************************************************************************************************
52932 -- OBJECTS using the class defined above
52933 --****************************************************************************************************
52936 myObject-1 MY-CLASS-1 ::=
52938 TYPE FIELD ASN1-Type3
52939 FIXED VALUE TYPE FIELD 999
52943 myObject-2 MY-CLASS-1 ::=
52945 TYPE FIELD ASN1-Type2
52946 FIXED VALUE TYPE FIELD 888
52949 myObject-3 MY-CLASS-1 ::=
52951 TYPE FIELD ASN1-Type4
52952 FIXED VALUE TYPE FIELD 555
52955 --****************************************************************************************************
52956 -- Defining Information Object sets
52957 --****************************************************************************************************
52959 MyInformationObjectSet1 MY-CLASS-1 ::=
52966 MyInformationObjectSet2 MY-CLASS-1 ::=
52968 MyInformationObjectSet1|
52973 BERPDU ::= SEQUENCE
52976 field1 MY-CLASS-1.&TypeField ({MyInformationObjectSet1} {@.field2} ),
52977 field2 MY-CLASS-1.&fixedTypeValueField ({MyInformationObjectSet1})
52984 import from TempA all;
52986 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52988 const BERPDU myValue := { field1 := {aSN1_Type3 := {f1 := 8}}, field2 := 999};
52993 if (dec_BER_PDU('30093003020108020203E7'O) == myValue)
52995 {setverdict(pass);} else {setverdict(fail);}
53000 Overall verdict: pass
53006 .*---------------------------------------------------------------------*
53007 :h3. DECODING ,OPEN TYPE, CER, from Information Object Class
53008 .*---------------------------------------------------------------------*
53011 <TC - DECODING ,OPEN TYPE, CER, from Information Object Class>
53022 --***************************************************************************************************
53023 --modified class taken from Gyuri ASN1
53024 --***************************************************************************************************
53025 MY-CLASS-1 ::= CLASS
53027 &TypeField OPTIONAL,
53028 &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL
53033 [TYPE FIELD &TypeField]
53034 [FIXED VALUE TYPE FIELD &fixedTypeValueField]
53037 ASN1-Type1 ::= INTEGER
53039 ASN1-Type2 ::= BOOLEAN
53041 ASN1-Type3 ::= SEQUENCE {f1 INTEGER}
53043 ASN1-Type4 ::= OCTET STRING
53046 --****************************************************************************************************
53047 -- OBJECTS using the class defined above
53048 --****************************************************************************************************
53051 myObject-1 MY-CLASS-1 ::=
53053 TYPE FIELD ASN1-Type3
53054 FIXED VALUE TYPE FIELD 999
53058 myObject-2 MY-CLASS-1 ::=
53060 TYPE FIELD ASN1-Type2
53061 FIXED VALUE TYPE FIELD 888
53064 myObject-3 MY-CLASS-1 ::=
53066 TYPE FIELD ASN1-Type4
53067 FIXED VALUE TYPE FIELD 555
53070 --****************************************************************************************************
53071 -- Defining Information Object sets
53072 --****************************************************************************************************
53074 MyInformationObjectSet1 MY-CLASS-1 ::=
53081 MyInformationObjectSet2 MY-CLASS-1 ::=
53083 MyInformationObjectSet1|
53088 BERPDU ::= SEQUENCE
53091 field1 MY-CLASS-1.&TypeField ({MyInformationObjectSet1} {@.field2} ),
53092 field2 MY-CLASS-1.&fixedTypeValueField ({MyInformationObjectSet1})
53099 import from TempA all;
53101 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
53103 const BERPDU myValue := { field1 := {aSN1_Type3 := {f1 := 8}}, field2 := 999};
53108 if (dec_BER_PDU('308030800201080000020203E70000'O) == myValue)
53110 {setverdict(pass);} else {setverdict(fail);}
53115 Overall verdict: pass
53121 .*---------------------------------------------------------------------*
53122 :h3. DECODING , TYPE from Information Object Class, DER
53123 .*---------------------------------------------------------------------*
53126 <TC - DECODING , TYPE from Information Object Class, DER>
53141 --***************************************************************************************************
53142 --modified class taken from Gyuri ASN1
53143 --***************************************************************************************************
53144 MY-CLASS-1 ::= CLASS
53146 &TypeField OPTIONAL,
53147 &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL
53152 [TYPE FIELD &TypeField]
53153 [FIXED VALUE TYPE FIELD &fixedTypeValueField]
53156 ASN1-Type1 ::= INTEGER
53158 ASN1-Type2 ::= BOOLEAN
53160 ASN1-Type3 ::= SEQUENCE {f1 INTEGER}
53162 ASN1-Type4 ::= OCTET STRING
53165 --****************************************************************************************************
53166 -- OBJECTS using the class defined above
53167 --****************************************************************************************************
53170 myObject-1 MY-CLASS-1 ::=
53172 TYPE FIELD ASN1-Type3
53173 FIXED VALUE TYPE FIELD 999
53177 myObject-2 MY-CLASS-1 ::=
53179 TYPE FIELD ASN1-Type2
53180 FIXED VALUE TYPE FIELD 888
53183 myObject-3 MY-CLASS-1 ::=
53185 TYPE FIELD ASN1-Type4
53186 FIXED VALUE TYPE FIELD 555
53189 --****************************************************************************************************
53190 -- Defining Information Object sets
53191 --****************************************************************************************************
53193 MyInformationObjectSet1 MY-CLASS-1 ::=
53200 MyInformationObjectSet2 MY-CLASS-1 ::=
53202 MyInformationObjectSet1|
53209 BERPDU ::= SEQUENCE
53212 field1 myObject-1.&TypeField , -- type from object
53213 field2 MY-CLASS-1.&fixedTypeValueField
53220 import from TempA all;
53222 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
53224 const BERPDU myValue := { field1 := {f1 := 8}, field2 := 999};
53229 if (dec_BER_PDU('30093003020108020203E7'O) == myValue)
53231 {setverdict(pass);} else {setverdict(fail);}
53236 Overall verdict: pass
53242 .*---------------------------------------------------------------------*
53243 :h3. DECODING , TYPE from Information Object Class, CER
53244 .*---------------------------------------------------------------------*
53247 <TC - DECODING , TYPE from Information Object Class, CER>
53262 --***************************************************************************************************
53263 --modified class taken from Gyuri ASN1
53264 --***************************************************************************************************
53265 MY-CLASS-1 ::= CLASS
53267 &TypeField OPTIONAL,
53268 &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL
53273 [TYPE FIELD &TypeField]
53274 [FIXED VALUE TYPE FIELD &fixedTypeValueField]
53277 ASN1-Type1 ::= INTEGER
53279 ASN1-Type2 ::= BOOLEAN
53281 ASN1-Type3 ::= SEQUENCE {f1 INTEGER}
53283 ASN1-Type4 ::= OCTET STRING
53286 --****************************************************************************************************
53287 -- OBJECTS using the class defined above
53288 --****************************************************************************************************
53291 myObject-1 MY-CLASS-1 ::=
53293 TYPE FIELD ASN1-Type3
53294 FIXED VALUE TYPE FIELD 999
53298 myObject-2 MY-CLASS-1 ::=
53300 TYPE FIELD ASN1-Type2
53301 FIXED VALUE TYPE FIELD 888
53304 myObject-3 MY-CLASS-1 ::=
53306 TYPE FIELD ASN1-Type4
53307 FIXED VALUE TYPE FIELD 555
53310 --****************************************************************************************************
53311 -- Defining Information Object sets
53312 --****************************************************************************************************
53314 MyInformationObjectSet1 MY-CLASS-1 ::=
53321 MyInformationObjectSet2 MY-CLASS-1 ::=
53323 MyInformationObjectSet1|
53330 BERPDU ::= SEQUENCE
53333 field1 myObject-1.&TypeField , -- type from object
53334 field2 MY-CLASS-1.&fixedTypeValueField
53341 import from TempA all;
53343 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
53345 const BERPDU myValue := { field1 := {f1 := 8}, field2 := 999};
53350 if (dec_BER_PDU('308030800201080000020203E70000'O) == myValue)
53352 {setverdict(pass);} else {setverdict(fail);}
53357 Overall verdict: pass
53364 .*---------------------------------------------------------------------*
53365 :h2.Testing Enc/Dec functions of implicit message encoding
53366 .*---------------------------------------------------------------------*
53367 .*---------------------------------------------------------------------*
53368 :h3. Fast enc/dec function
53369 .*---------------------------------------------------------------------*
53372 <TC- Implicit message encoding: prototype fast>
53381 BERPDU ::= SEQUENCE
53394 import from TempA all;
53395 external function enc_DER_PDU(in BERPDU pdu, out octetstring os) with { extension "prototype(fast) encode(BER:BER_ENCODE_DER)" }
53396 external function enc_CER_PDU(in BERPDU pdu, out octetstring os) with { extension "prototype(fast) encode(BER:BER_ENCODE_CER)" }
53397 external function dec_BER_PDU(in octetstring os, out BERPDU pdu)
53398 with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53400 const BERPDU myValue := {
53408 var octetstring der_encoded, cer_encoded;
53409 var BERPDU der_decoded, cer_decoded;
53411 enc_DER_PDU(myValue, der_encoded);
53412 enc_CER_PDU(myValue, cer_encoded);
53414 if ((der_encoded == '300D8001FF8101FF83020780820104'O) and
53415 (cer_encoded == '30808001FF8101FF830207808201040000'O))
53416 {setverdict(pass);} else {setverdict(fail);}
53418 dec_BER_PDU(der_encoded, der_decoded);
53419 if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);}
53420 dec_BER_PDU(cer_encoded, cer_decoded);
53421 if (cer_decoded==myValue) {setverdict(pass);} else {setverdict(fail);}
53425 Overall verdict: pass
53431 .*---------------------------------------------------------------------*
53432 :h3. Backtrack decode function
53433 .*---------------------------------------------------------------------*
53436 <TC- Implicit message encoding: prototype backtrack>
53445 STRPDU ::= PrintableString
53446 USTRPDU ::= GeneralString
53447 SEQPDU ::= SEQUENCE {
53456 import from TempA all;
53458 external function encode_str(in STRPDU pdu) return octetstring
53459 with { extension "prototype(convert) encode(BER)" }
53460 external function encode_ustr(in USTRPDU updu) return octetstring
53461 with { extension "prototype(convert) encode(BER)" }
53462 external function encode_seq(in SEQPDU pdu) return octetstring
53463 with { extension "prototype(convert) encode(BER)" }
53464 external function decode_str(in octetstring os, out STRPDU pdu) return integer
53465 with { extension "prototype(backtrack) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53466 external function decode_ustr(in octetstring os, out USTRPDU pdu) return integer
53467 with { extension "prototype(backtrack) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53468 external function decode_seq(in octetstring os, out SEQPDU pdu) return integer
53469 with { extension "prototype(backtrack) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53473 var STRPDU str := "haha";
53474 var USTRPDU ustr := "uu";
53475 var SEQPDU seq := { 123, 'ABCDEF'O, true }
53476 var STRPDU decoded_str;
53477 var USTRPDU decoded_ustr;
53478 var SEQPDU decoded_seq;
53479 var integer ret_val;
53481 ret_val := decode_str(encode_str(str), decoded_str);
53482 if (ret_val==0 and decoded_str==str) {setverdict(pass);} else {setverdict(fail);}
53483 ret_val := decode_ustr(encode_ustr(ustr), decoded_ustr);
53484 if (ret_val==0 and decoded_ustr==ustr) {setverdict(pass);} else {setverdict(fail);}
53485 ret_val := decode_seq(encode_seq(seq), decoded_seq);
53486 if (ret_val==0 and decoded_seq==seq) {setverdict(pass);} else {setverdict(fail);}
53488 ret_val := decode_str(''O, decoded_str);
53489 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53490 ret_val := decode_ustr(''O, decoded_ustr);
53491 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53492 ret_val := decode_seq(''O, decoded_seq);
53493 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53495 ret_val := decode_str('12'O, decoded_str);
53496 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53497 ret_val := decode_ustr('12'O, decoded_ustr);
53498 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53499 ret_val := decode_seq('12'O, decoded_seq);
53500 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53502 ret_val := decode_str('1234'O, decoded_str);
53503 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53504 ret_val := decode_ustr('1234'O, decoded_ustr);
53505 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53506 ret_val := decode_seq('1234'O, decoded_seq);
53507 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53511 Overall verdict: pass
53517 .*---------------------------------------------------------------------*
53518 :h3. Sliding decode function
53519 .*---------------------------------------------------------------------*
53522 <TC- Implicit message encoding: prototype sliding>
53540 import from TempA all;
53542 external function encode_PDU(in PDU pdu) return octetstring
53543 with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53544 external function decode_PDU(inout octetstring os, out PDU pdu) return integer
53545 with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53549 var PDU pdu := { 123, 'ABCDEF'O, true }
53550 var octetstring encoded_pdu;
53551 var PDU decoded_pdu;
53552 var integer ret_val;
53554 encoded_pdu := encode_PDU(pdu);
53555 ret_val := decode_PDU(encoded_pdu, decoded_pdu);
53556 if (ret_val==0 and decoded_pdu==pdu) {setverdict(pass);} else {setverdict(fail);}
53558 encoded_pdu := '800100'O;
53559 ret_val := decode_PDU(encoded_pdu, decoded_pdu);
53560 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53562 encoded_pdu := substr(encode_PDU(pdu), 0, 4);
53563 ret_val := decode_PDU(encoded_pdu, decoded_pdu);
53564 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53568 Overall verdict: pass
53574 .*---------------------------------------------------------------------*
53575 :h3. Sliding decoding, octetstring length 0,1,2 -> incomplete TLV
53576 .*---------------------------------------------------------------------*
53579 <TC- Implicit message encoding: incomplete TLV>
53591 PDU3 ::= ENUMERATED { e0 (0), e1 (1) }
53593 PDU5 ::= BIT STRING
53594 PDU6 ::= OCTET STRING
53595 PDU7 ::= PrintableString
53596 PDU8 ::= GeneralString
53597 PDU9 ::= CHOICE { i INTEGER, b BOOLEAN }
53598 PDU10 ::= SEQUENCE { i INTEGER, b BOOLEAN }
53599 PDU11 ::= SEQUENCE OF INTEGER
53600 PDU12 ::= OBJECT IDENTIFIER
53605 import from TempA all;
53607 external function encode_PDU0(in PDU0 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53608 external function decode_PDU0(inout octetstring os, out PDU0 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53610 external function encode_PDU1(in PDU1 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53611 external function decode_PDU1(inout octetstring os, out PDU1 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53613 external function encode_PDU2(in PDU2 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53614 external function decode_PDU2(inout octetstring os, out PDU2 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53616 external function encode_PDU3(in PDU3 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53617 external function decode_PDU3(inout octetstring os, out PDU3 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53619 external function encode_PDU4(in PDU4 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53620 external function decode_PDU4(inout octetstring os, out PDU4 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53622 external function encode_PDU5(in PDU5 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53623 external function decode_PDU5(inout octetstring os, out PDU5 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53625 external function encode_PDU6(in PDU6 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53626 external function decode_PDU6(inout octetstring os, out PDU6 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53628 external function encode_PDU7(in PDU7 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53629 external function decode_PDU7(inout octetstring os, out PDU7 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53631 external function encode_PDU8(in PDU8 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53632 external function decode_PDU8(inout octetstring os, out PDU8 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53634 external function encode_PDU9(in PDU9 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53635 external function decode_PDU9(inout octetstring os, out PDU9 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53637 external function encode_PDU10(in PDU10 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53638 external function decode_PDU10(inout octetstring os, out PDU10 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53640 external function encode_PDU11(in PDU11 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53641 external function decode_PDU11(inout octetstring os, out PDU11 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53643 external function encode_PDU12(in PDU12 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53644 external function decode_PDU12(inout octetstring os, out PDU12 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53648 var octetstring encoded_pdu;
53649 var integer ret_val;
53651 var PDU0 pdu0 := NULL;
53652 var PDU0 decoded_pdu0;
53653 encoded_pdu := substr(encode_PDU0(pdu0), 0, 0);
53654 ret_val := decode_PDU0(encoded_pdu, decoded_pdu0);
53655 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53656 encoded_pdu := substr(encode_PDU0(pdu0), 0, 1);
53657 ret_val := decode_PDU0(encoded_pdu, decoded_pdu0);
53658 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53660 var PDU1 pdu1 := true;
53661 var PDU1 decoded_pdu1;
53662 encoded_pdu := substr(encode_PDU1(pdu1), 0, 0);
53663 ret_val := decode_PDU1(encoded_pdu, decoded_pdu1);
53664 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53665 encoded_pdu := substr(encode_PDU1(pdu1), 0, 1);
53666 ret_val := decode_PDU1(encoded_pdu, decoded_pdu1);
53667 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53668 encoded_pdu := substr(encode_PDU1(pdu1), 0, 2);
53669 ret_val := decode_PDU1(encoded_pdu, decoded_pdu1);
53670 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53672 var PDU2 pdu2 := 123;
53673 var PDU2 decoded_pdu2;
53674 encoded_pdu := substr(encode_PDU2(pdu2), 0, 0);
53675 ret_val := decode_PDU2(encoded_pdu, decoded_pdu2);
53676 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53677 encoded_pdu := substr(encode_PDU2(pdu2), 0, 1);
53678 ret_val := decode_PDU2(encoded_pdu, decoded_pdu2);
53679 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53680 encoded_pdu := substr(encode_PDU2(pdu2), 0, 2);
53681 ret_val := decode_PDU2(encoded_pdu, decoded_pdu2);
53682 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53684 var PDU3 pdu3 := e1;
53685 var PDU3 decoded_pdu3;
53686 encoded_pdu := substr(encode_PDU3(pdu3), 0, 0);
53687 ret_val := decode_PDU3(encoded_pdu, decoded_pdu3);
53688 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53689 encoded_pdu := substr(encode_PDU3(pdu3), 0, 1);
53690 ret_val := decode_PDU3(encoded_pdu, decoded_pdu3);
53691 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53692 encoded_pdu := substr(encode_PDU3(pdu3), 0, 2);
53693 ret_val := decode_PDU3(encoded_pdu, decoded_pdu3);
53694 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53696 var PDU4 pdu4 := 1.23;
53697 var PDU4 decoded_pdu4;
53698 encoded_pdu := substr(encode_PDU4(pdu4), 0, 0);
53699 ret_val := decode_PDU4(encoded_pdu, decoded_pdu4);
53700 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53701 encoded_pdu := substr(encode_PDU4(pdu4), 0, 1);
53702 ret_val := decode_PDU4(encoded_pdu, decoded_pdu4);
53703 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53704 encoded_pdu := substr(encode_PDU4(pdu4), 0, 2);
53705 ret_val := decode_PDU4(encoded_pdu, decoded_pdu4);
53706 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53708 var PDU5 pdu5 := '101010'B;
53709 var PDU5 decoded_pdu5;
53710 encoded_pdu := substr(encode_PDU5(pdu5), 0, 0);
53711 ret_val := decode_PDU5(encoded_pdu, decoded_pdu5);
53712 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53713 encoded_pdu := substr(encode_PDU5(pdu5), 0, 1);
53714 ret_val := decode_PDU5(encoded_pdu, decoded_pdu5);
53715 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53716 encoded_pdu := substr(encode_PDU5(pdu5), 0, 2);
53717 ret_val := decode_PDU5(encoded_pdu, decoded_pdu5);
53718 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53720 var PDU6 pdu6 := 'ABCDEF12'O;
53721 var PDU6 decoded_pdu6;
53722 encoded_pdu := substr(encode_PDU6(pdu6), 0, 0);
53723 ret_val := decode_PDU6(encoded_pdu, decoded_pdu6);
53724 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53725 encoded_pdu := substr(encode_PDU6(pdu6), 0, 1);
53726 ret_val := decode_PDU6(encoded_pdu, decoded_pdu6);
53727 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53728 encoded_pdu := substr(encode_PDU6(pdu6), 0, 2);
53729 ret_val := decode_PDU6(encoded_pdu, decoded_pdu6);
53730 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53732 var PDU7 pdu7 := "haha";
53733 var PDU7 decoded_pdu7;
53734 encoded_pdu := substr(encode_PDU7(pdu7), 0, 0);
53735 ret_val := decode_PDU7(encoded_pdu, decoded_pdu7);
53736 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53737 encoded_pdu := substr(encode_PDU7(pdu7), 0, 1);
53738 ret_val := decode_PDU7(encoded_pdu, decoded_pdu7);
53739 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53740 encoded_pdu := substr(encode_PDU7(pdu7), 0, 2);
53741 ret_val := decode_PDU7(encoded_pdu, decoded_pdu7);
53742 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53744 var PDU8 pdu8 := "huhu";
53745 var PDU8 decoded_pdu8;
53746 encoded_pdu := substr(encode_PDU8(pdu8), 0, 0);
53747 ret_val := decode_PDU8(encoded_pdu, decoded_pdu8);
53748 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53749 encoded_pdu := substr(encode_PDU8(pdu8), 0, 1);
53750 ret_val := decode_PDU8(encoded_pdu, decoded_pdu8);
53751 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53752 encoded_pdu := substr(encode_PDU8(pdu8), 0, 2);
53753 ret_val := decode_PDU8(encoded_pdu, decoded_pdu8);
53754 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53756 var PDU9 pdu9 := { b := true }
53757 var PDU9 decoded_pdu9;
53758 encoded_pdu := substr(encode_PDU9(pdu9), 0, 0);
53759 ret_val := decode_PDU9(encoded_pdu, decoded_pdu9);
53760 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53761 encoded_pdu := substr(encode_PDU9(pdu9), 0, 1);
53762 ret_val := decode_PDU9(encoded_pdu, decoded_pdu9);
53763 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53764 encoded_pdu := substr(encode_PDU9(pdu9), 0, 2);
53765 ret_val := decode_PDU9(encoded_pdu, decoded_pdu9);
53766 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53768 var PDU10 pdu10 := { 123 , true }
53769 var PDU10 decoded_pdu10;
53770 encoded_pdu := substr(encode_PDU10(pdu10), 0, 0);
53771 ret_val := decode_PDU10(encoded_pdu, decoded_pdu10);
53772 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53773 encoded_pdu := substr(encode_PDU10(pdu10), 0, 1);
53774 ret_val := decode_PDU10(encoded_pdu, decoded_pdu10);
53775 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53776 encoded_pdu := substr(encode_PDU10(pdu10), 0, 2);
53777 ret_val := decode_PDU10(encoded_pdu, decoded_pdu10);
53778 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53780 var PDU11 pdu11 := { 1, 2, 3 }
53781 var PDU11 decoded_pdu11;
53782 encoded_pdu := substr(encode_PDU11(pdu11), 0, 0);
53783 ret_val := decode_PDU11(encoded_pdu, decoded_pdu11);
53784 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53785 encoded_pdu := substr(encode_PDU11(pdu11), 0, 1);
53786 ret_val := decode_PDU11(encoded_pdu, decoded_pdu11);
53787 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53788 encoded_pdu := substr(encode_PDU11(pdu11), 0, 2);
53789 ret_val := decode_PDU11(encoded_pdu, decoded_pdu11);
53790 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53792 var PDU12 pdu12 := objid { itu_t(0) 4 }
53793 var PDU12 decoded_pdu12;
53794 encoded_pdu := substr(encode_PDU12(pdu12), 0, 0);
53795 ret_val := decode_PDU12(encoded_pdu, decoded_pdu12);
53796 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53797 encoded_pdu := substr(encode_PDU12(pdu12), 0, 1);
53798 ret_val := decode_PDU12(encoded_pdu, decoded_pdu12);
53799 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53800 encoded_pdu := substr(encode_PDU12(pdu12), 0, 2);
53801 ret_val := decode_PDU12(encoded_pdu, decoded_pdu12);
53802 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53806 Overall verdict: pass
53812 .*---------------------------------------------------------------------*
53813 :h2. Encoding/decoding of big integers
53814 .*---------------------------------------------------------------------*
53815 .*---------------------------------------------------------------------*
53816 :h3. Encoding/decoding of big integers
53817 .*---------------------------------------------------------------------*
53820 <TC - Encoding/decoding of big integers>
53824 TempA DEFINITIONS AUTOMATIC TAGS ::=
53831 bi4 BERPDU ::= -128
53833 bi-6 BERPDU ::= 128
53834 bi7 BERPDU ::= -129
53837 --b BERPDU2 ::= 12345678900
53839 Rec-ber ::= SEQUENCE {
53843 Rec-ber-literal ::= SEQUENCE {
53848 NumberLit ::= NumericString (SIZE (100))
53849 myNumber Number ::= 12345678910111213141516
53855 import from TempA language "ASN.1:1997" all
53857 external function enc_ber1(in Rec_ber r) return octetstring
53858 with { extension "encode(BER:BER_ENCODE_DER) prototype(convert) errorbehavior(ALL:WARNING)" }
53859 external function dec_ber1(in octetstring r) return Rec_ber
53860 with { extension "decode(BER:BER_ACCEPT_ALL) prototype(convert) errorbehavior(ALL:WARNING)" }
53861 external function enc_ber2(in integer r) return octetstring
53862 with { extension "encode(BER:BER_ENCODE_DER) prototype(convert) errorbehavior(ALL:WARNING)" }
53863 // Attributes are not checked in the compiler.
53864 external function dec_ber2(in octetstring r) return integer
53865 with { extension "decode(BER:BER_ENCODE_DER) prototype(convert) errorbehavior(ALL:WARNING)" }
53866 external function dec_ber3(inout octetstring r, out Rec_ber s) return integer
53867 with { extension "decode(BER:BER_ACCEPT_ALL) prototype(sliding) errorbehavior(ALL:WARNING)" }
53869 type component comp_ber { }
53873 const integer a := 2147483647
53874 const integer b := 2147483648
53875 const integer c := 2147483649
53876 const integer d := 128
53877 const integer e := myNumber
53878 const integer f := 12147483648
53879 var Rec_ber myrec1 := {int1 := a, int2 := b}
53880 var Rec_ber myrec2 := {int1 := c, int2 := d}
53881 var Rec_ber myrec3 := {int1 := 1048576, int2 := 321768}
53882 var Rec_ber myrec4 := {65536, 131072}
53883 var Rec_ber myrec5 := {4294967296, 8388608}
53884 var Rec_ber myrec6 := {12345678910111213141516, 11111111111111111111}
53885 var Rec_ber myrec7 := {8589934592, 1099511627776}
53886 var Rec_ber myrec8 := {int1 := a, int2 := b}
53887 var Rec_ber myrec9 := {int1 := 12345678910111213141516, int2 := -1234}
53888 var Rec_ber myrec10 := {int1 := -12345678910111213141516, int2 := -1234}
53889 var Rec_ber myrec11 := {2147483648, -2147483648}
53890 var Rec_ber myrec12 := {-2147483647, 2147483647}
53891 var Rec_ber myrec13 := {2147483649, -2147483649}
53892 var Rec_ber myrec14 := {-4294967296, 4294967296}
53893 var Rec_ber myrec15 := {4294967295, -4294967295}
53894 var Rec_ber myrec16 := {-4294967297, 4294967297}
53895 var Rec_ber pdu1 := {12345678910111213141516, -2147483648}
53896 var Rec_ber pdu2 := {123, 456}
53897 var octetstring encoded_pdu
53898 var Rec_ber decoded_pdu
53899 var integer ret_val
53900 encoded_pdu := enc_ber1(pdu2)
53901 ret_val := dec_ber3(encoded_pdu, decoded_pdu)
53902 if (ret_val == 0 and decoded_pdu == pdu2) {setverdict(pass)} else {setverdict(fail)}
53903 encoded_pdu := '800100'O
53904 ret_val := dec_ber3(encoded_pdu, decoded_pdu)
53905 if (ret_val == 2) {setverdict(pass)} else {setverdict(fail)}
53906 encoded_pdu := substr(enc_ber1(pdu1), 0, 4)
53907 ret_val := dec_ber3(encoded_pdu, decoded_pdu)
53908 if (ret_val == 2) {setverdict(pass)} else {setverdict(fail)}
53909 encoded_pdu := enc_ber2(-2147483648)
53910 if (encoded_pdu == '020480000000'O) {setverdict(pass)} else {setverdict(fail)}
53911 encoded_pdu := enc_ber1(myrec1)
53912 if (myrec1 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53913 if ({int1 := a, int2 := b} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53914 encoded_pdu := enc_ber1(myrec2)
53915 if (myrec2 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53916 if ({int1 := c, int2 := d} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53917 encoded_pdu := enc_ber1(myrec3)
53918 if (myrec3 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53919 if ({int1 := 1048576, int2 := 321768} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53920 encoded_pdu := enc_ber1(myrec4)
53921 if (myrec4 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53922 if ({65536, 131072} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53923 encoded_pdu := enc_ber1(myrec5)
53924 if (myrec5 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53925 if ({4294967296, 8388608} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53926 encoded_pdu := enc_ber1(myrec6)
53927 if (myrec6 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53928 if ({12345678910111213141516, 11111111111111111111} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53929 encoded_pdu := enc_ber1(myrec7)
53930 if (myrec7 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53931 if ({8589934592, 1099511627776} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53932 encoded_pdu := enc_ber1(myrec8)
53933 if (myrec8 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53934 if ({int1 := a, int2 := b} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53935 encoded_pdu := enc_ber1(myrec9)
53936 if (myrec9 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53937 if ({int1 := 12345678910111213141516, int2 := -1234} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53938 encoded_pdu := enc_ber1(myrec10)
53939 if (myrec10 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53940 if ({int1 := -12345678910111213141516, int2 := -1234} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53941 encoded_pdu := enc_ber1(myrec11)
53942 if (myrec11 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53943 if ({2147483648, -2147483648} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53944 encoded_pdu := enc_ber1(myrec12)
53945 if (myrec12 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53946 if ({-2147483647, 2147483647} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53947 encoded_pdu := enc_ber1(myrec13)
53948 if (myrec13 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53949 if ({2147483649, -2147483649} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53950 encoded_pdu := enc_ber1(myrec14)
53951 if (myrec14 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53952 if ({-4294967296, 4294967296} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53953 encoded_pdu := enc_ber1(myrec15)
53954 if (myrec15 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53955 if ({4294967295, -4294967295} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53956 encoded_pdu := enc_ber1(myrec16)
53957 if (myrec16 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53958 if ({-4294967297, 4294967297} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53963 Overall verdict: pass
53969 .*---------------------------------------------------------------------*
53971 .*---------------------------------------------------------------------*
53972 Negative tests for the BER decoder.
53973 .*---------------------------------------------------------------------*
53975 .*---------------------------------------------------------------------*
53977 .*---------------------------------------------------------------------*
53978 :h3. BER decoding REAL, decimal form NR3 pretending to be NR1
53979 .*---------------------------------------------------------------------*
53982 <TC- BER decoding REAL, decimal form NR3 pretending to be NR1>
53992 IMPORTS; -- nothing
54002 external function dec_BER_PDU(in octetstring os, out BERPDU pdu)
54003 with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " }
54005 // pi: 31415926.E-7
54006 const octetstring der_encoded := '090D0133313431353932362E452D37'O;
54007 const BERPDU myValue := 3.1415926;
54011 var BERPDU der_decoded, cer_decoded;
54013 dec_BER_PDU(der_encoded, der_decoded);
54014 if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);}
54018 Dynamic test case error: While BER-decoding type '@Temp.BERPDU': While decoding REAL type: This decimal encoding does not conform to NR1 form.
54025 .*---------------------------------------------------------------------*
54026 :h3. BER decoding REAL, decimal form NR3 pretending to be NR2
54027 .*---------------------------------------------------------------------*
54030 <TC- BER decoding REAL, decimal form NR3 pretending to be NR2>
54040 IMPORTS; -- nothing
54050 external function dec_BER_PDU(in octetstring os, out BERPDU pdu)
54051 with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " }
54053 // pi: 31415926.E-7
54054 const octetstring der_encoded := '090D0233313431353932362E452D37'O;
54055 const BERPDU myValue := 3.1415926;
54059 var BERPDU der_decoded, cer_decoded;
54061 dec_BER_PDU(der_encoded, der_decoded);
54062 if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);}
54066 Dynamic test case error: While BER-decoding type '@Temp.BERPDU': While decoding REAL type: This decimal encoding does not conform to NR2 form.
54072 .*---------------------------------------------------------------------*
54073 :h3. BER decoding REAL, reserved decimal form 0x20
54074 .*---------------------------------------------------------------------*
54077 <TC- BER decoding REAL, reserved decimal form 0x20>
54087 IMPORTS; -- nothing
54097 external function dec_BER_PDU(in octetstring os, out BERPDU pdu)
54098 with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " }
54100 // pi: 31415926.E-7
54101 const octetstring der_encoded := '090D2033313431353932362E452D37'O;
54102 const BERPDU myValue := 3.1415926;
54106 var BERPDU der_decoded, cer_decoded;
54108 dec_BER_PDU(der_encoded, der_decoded);
54109 if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);}
54113 Dynamic test case error: While BER-decoding type '@Temp.BERPDU': While decoding REAL type: This is a reserved value: 0x20 (See X.690 8.5.7).
54120 .*---------------------------------------------------------------------*
54121 :h3. BER decoding REAL, decimal form 0
54122 .*---------------------------------------------------------------------*
54125 <TC- BER decoding REAL, decimal form 0>
54135 IMPORTS; -- nothing
54145 external function dec_BER_PDU(in octetstring os, out BERPDU pdu)
54146 with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " }
54148 // pi: 31415926.E-7
54149 const octetstring der_encoded := '090D0033313431353932362E452D37'O;
54150 const BERPDU myValue := 3.1415926;
54154 var BERPDU der_decoded, cer_decoded;
54156 dec_BER_PDU(der_encoded, der_decoded);
54157 if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);}
54161 Dynamic test case error: While BER-decoding type '@Temp.BERPDU': While decoding REAL type: This is a reserved value: 0x0 (See X.690 8.5.7).
54168 .*---------------------------------------------------------------------*
54169 :h3. BER decoding REAL, decimal form 4
54170 .*---------------------------------------------------------------------*
54173 <TC- BER decoding REAL, decimal form 4>
54183 IMPORTS; -- nothing
54193 external function dec_BER_PDU(in octetstring os, out BERPDU pdu)
54194 with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " }
54196 // pi: 31415926.E-7
54197 const octetstring der_encoded := '090D0433313431353932362E452D37'O;
54198 const BERPDU myValue := 3.1415926;
54202 var BERPDU der_decoded, cer_decoded;
54204 dec_BER_PDU(der_encoded, der_decoded);
54205 if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);}
54209 Dynamic test case error: While BER-decoding type '@Temp.BERPDU': While decoding REAL type: This is a reserved value: 0x4 (See X.690 8.5.7).
54215 .*---------------------------------------------------------------------*
54216 :h3. Memory leak while BER decoding, test for HO73756
54217 .*---------------------------------------------------------------------*
54220 <TC - Memory leak while BER decoding, test for HO73756>
54223 TempA DEFINITIONS ::=
54226 MY-CLASS-1 ::= CLASS
54228 &TypeField OPTIONAL,
54229 &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL
54234 [TYPE FIELD &TypeField]
54235 [FIXED VALUE TYPE FIELD &fixedTypeValueField]
54238 ASN1-Type1 ::= INTEGER
54240 ASN1-Type2 ::= BOOLEAN
54242 ASN1-Type3 ::= SEQUENCE {f1 INTEGER}
54244 ASN1-Type4 ::= OCTET STRING
54246 myObject-1 MY-CLASS-1 ::=
54248 TYPE FIELD ASN1-Type3
54249 FIXED VALUE TYPE FIELD 999
54252 myObject-2 MY-CLASS-1 ::=
54254 TYPE FIELD ASN1-Type2
54255 FIXED VALUE TYPE FIELD 888
54258 myObject-3 MY-CLASS-1 ::=
54260 TYPE FIELD ASN1-Type4
54261 FIXED VALUE TYPE FIELD 555
54264 MyInformationObjectSet1 MY-CLASS-1 ::=
54266 myObject-1|myObject-2,
54270 MyInformationObjectSet2 MY-CLASS-1 ::=
54272 MyInformationObjectSet1|myObject-3,
54276 BERPDU ::= SEQUENCE
54278 field1 MY-CLASS-1.&TypeField ({MyInformationObjectSet1} {@.field2} ),
54279 field2 MY-CLASS-1.&fixedTypeValueField ({MyInformationObjectSet1})
54284 // Test for memory leak problem in BER decoder: HO73756.
54285 import from TempA all;
54287 external function dec_backtrack(in octetstring stream, out BERPDU outpdu) return integer with { extension "prototype(backtrack) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
54289 type component empty {
54293 <TTCN_TC:PURE_EXEC>
54295 testcase mytc() runs on empty {
54296 dec_backtrack('30093003020108020203E7'O, mypdu)
54297 dec_backtrack('30093003020108020203E7'O, mypdu)
54307 Overall verdict: pass
54313 .*---------------------------------------------------------------------*
54315 .*---------------------------------------------------------------------*
54316 :nl. Requirement specification(s):
54317 :nl.-------------------------------
54319 :li. 8/ETH/RUS-2003:0087 Uen - Requirement Specification for TITAN's encoder/decoder functions