1 .******************************************************************************
2 .* Copyright (c) 2000-2016 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
17 .* Szabo, Janos Zoltan – initial implementation
20 .******************************************************************************/
24 :docname.Test Description
25 :docno.8/152 91-CRL 113 200/3 Uen
29 :prep.ETH/XZR Krisztian Pandi
30 :appr.ETH/XZ (Gyula Koos)
33 :title.Test Description - BER coder
35 .*---------------------------------------------------------------------*
36 :h1.PREREQUISITES AND PREPARATIONS
37 .*---------------------------------------------------------------------*
38 .*---------------------------------------------------------------------*
39 :h2.Scope of the Test Object
40 .*---------------------------------------------------------------------*
43 This file is obsolate, don't modify, improve it anymore!
45 This TD contains test cases related to TTCN3 Executor's BER coder function.
46 DON'T YOU DARE TO WRITE AN INSPECTION RECORD ABOUT THIS FILE.
50 :p.:us.Revision Information:eus.
55 REV DATE PREPARED CHANGE
56 === ========== ======== ======
57 A 2003-10-31 ETHEKR New document
58 B 2007-03-06 EDMDELI Implicit message encoding
59 C 2007-03-21 EJNOSZA Bugfix in a testcase for implicit msg. enc.
60 D 2008-10-01 EFERKOV Big integers
61 E 2010-01-18 EKRISZA Updated for TITAN R8C
62 F 2011-06-18 EKRISZA Added tests for errors
63 A 2011-12-12 EKRISZA Updated for release
64 A 2012-06-27 EFERKOV Updated for release
65 A 2013-01-17 EKRIPND Updated for release
68 .*---------------------------------------------------------------------*
70 .*---------------------------------------------------------------------*
71 :p.:us.Software Tools:eus.
78 .*---------------------------------------------------------------------*
79 :h1.REQUIREMENT-BASED TESTS
80 .*---------------------------------------------------------------------*
81 .*---------------------------------------------------------------------*
82 :h2.Testing FIELDLENGTH Attribute
83 .*---------------------------------------------------------------------*
84 .*---------------------------------------------------------------------*
85 :h3. DER + CER encoding of BOOLEAN TRUE
86 .*---------------------------------------------------------------------*
89 <TC - DER + CER encoding of BOOLEAN TRUE >
104 import from TempA all;
105 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
106 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
108 const BERPDU b := true
112 if ((enc_DER_PDU(b) == '0101FF'O)and(enc_CER_PDU(b) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);}
116 Overall verdict: pass
122 .*---------------------------------------------------------------------*
123 :h3. DER + CER encoding of BOOLEAN FALSE
124 .*---------------------------------------------------------------------*
127 <TC - DER + CER encoding of BOOLEAN FALSE >
140 import from TempA all;
141 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
142 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
144 const BERPDU b := false
148 if ((enc_DER_PDU(b) == '010100'O)and(enc_CER_PDU(b) == '010100'O)) {setverdict(pass);} else {setverdict(fail);}
152 Overall verdict: pass
158 .*---------------------------------------------------------------------*
159 :h3. DER + CER encoding of BOOLEAN with Context Specific TAG, EXPLICIT
160 .*---------------------------------------------------------------------*
163 <TC - DER + CER encoding of BOOLEAN with Context Specific TAG, EXPLICIT>
171 BERPDU ::= [0] EXPLICIT BOOLEAN
176 import from TempA all;
177 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
178 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
180 const BERPDU b := true
184 if ((enc_DER_PDU(b) == 'A0030101FF'O)and(enc_CER_PDU(b) == 'A0800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
188 Overall verdict: pass
194 .*---------------------------------------------------------------------*
195 :h3. DER + CER encoding of BOOLEAN with PRIVATE TAG, EXPLICIT
196 .*---------------------------------------------------------------------*
199 <TC - DER + CER encoding of BOOLEAN with PRIVATE TAG, EXPLICIT>
207 BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN
212 import from TempA all;
213 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
214 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
216 const BERPDU b := true
220 if ((enc_DER_PDU(b) == 'E1030101FF'O)and(enc_CER_PDU(b) == 'E1800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
224 Overall verdict: pass
230 .*---------------------------------------------------------------------*
231 :h3. DER + CER encoding of BOOLEAN with APPLICATION TAG, EXPLICIT
232 .*---------------------------------------------------------------------*
235 <TC - DER + CER encoding of BOOLEAN with APPLICATION TAG, EXPLICIT>
243 BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN
248 import from TempA all;
249 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
250 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
252 const BERPDU b := true
256 if ((enc_DER_PDU(b) == '62030101FF'O)and(enc_CER_PDU(b) == '62800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
260 Overall verdict: pass
266 .*---------------------------------------------------------------------*
267 :h3. DER + CER encoding of BOOLEAN with Context Specific TAG, IMPLICIT
268 .*---------------------------------------------------------------------*
271 <TC - DER + CER encoding of BOOLEAN with Context Specific TAG, IMPLICIT>
279 BERPDU ::= [0] IMPLICIT BOOLEAN
284 import from TempA all;
285 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
286 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
288 const BERPDU b := false
292 if ((enc_DER_PDU(b) == '800100'O)and(enc_CER_PDU(b) == '800100'O)) {setverdict(pass);} else {setverdict(fail);}
296 Overall verdict: pass
302 .*---------------------------------------------------------------------*
303 :h3. DER + CER encoding of BOOLEAN with PRIVATE TAG, IMPLICIT
304 .*---------------------------------------------------------------------*
307 <TC - DER + CER encoding of BOOLEAN with PRIVATE TAG, IMPLICIT>
315 BERPDU ::= [PRIVATE 1] IMPLICIT BOOLEAN
320 import from TempA all;
321 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
322 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
324 const BERPDU b := false
328 if ((enc_DER_PDU(b) == 'C10100'O)and(enc_CER_PDU(b) == 'C10100'O)) {setverdict(pass);} else {setverdict(fail);}
332 Overall verdict: pass
338 .*---------------------------------------------------------------------*
339 :h3. DER + CER encoding of BOOLEAN with APPLICATION TAG, IMPLICIT
340 .*---------------------------------------------------------------------*
343 <TC - DER + CER encoding of BOOLEAN with APPLICATION TAG, IMPLICIT>
351 BERPDU ::= [APPLICATION 2] IMPLICIT BOOLEAN
356 import from TempA all;
357 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
358 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
360 const BERPDU b := true
364 if ((enc_DER_PDU(b) == '4201FF'O)and(enc_CER_PDU(b) == '4201FF'O)) {setverdict(pass);} else {setverdict(fail);}
368 Overall verdict: pass
374 .*---------------------------------------------------------------------*
375 :h3. DECODING BOOLEAN, CER+DER
376 .*---------------------------------------------------------------------*
379 <TC - DECODING BOOLEAN, CER+DER>
389 myBooleanValue BERPDU ::= TRUE
395 import from TempA all;
397 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
402 if (dec_BER_PDU('0101FF'O) == myBooleanValue)
405 {setverdict(pass);} else {setverdict(fail);}
410 Overall verdict: pass
416 .*---------------------------------------------------------------------*
417 :h3. DECODING BOOLEAN, CER+DER
418 .*---------------------------------------------------------------------*
421 <TC - DECODING BOOLEAN, CER+DER>
431 myBooleanValue BERPDU ::= FALSE
437 import from TempA all;
439 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
444 if (dec_BER_PDU('010100'O) == myBooleanValue)
447 {setverdict(pass);} else {setverdict(fail);}
452 Overall verdict: pass
458 .*---------------------------------------------------------------------*
459 :h3. DECODING BOOLEAN, (LENGTH OF LENGTH = 1)
460 .*---------------------------------------------------------------------*
463 <TC - DECODING BOOLEAN, (LENGTH OF LENGTH = 1)>
473 myBooleanValue BERPDU ::= TRUE
479 import from TempA all;
481 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
486 if (dec_BER_PDU('05810101'O) == myBooleanValue)
489 {setverdict(pass);} else {setverdict(fail);}
494 Overall verdict: pass
500 .*---------------------------------------------------------------------*
501 :h3. DECODING BOOELAN, (LENGTH OF LENGTH = 2)
502 .*---------------------------------------------------------------------*
505 <TC - DECODING BOOELAN, (LENGTH OF LENGTH = 2)>
515 myBooleanValue BERPDU ::= FALSE
521 import from TempA all;
523 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
528 if (dec_BER_PDU('0582000100'O) == myBooleanValue)
531 {setverdict(pass);} else {setverdict(fail);}
536 Overall verdict: pass
542 .*---------------------------------------------------------------------*
543 :h3. DECODING [0] EXPLICIT BOOLEAN , DER, Short form - short form
544 .*---------------------------------------------------------------------*
547 <TC - DECODING [0] EXPLICIT BOOLEAN , DER, Short form - short form>
555 BERPDU ::= [0] EXPLICIT BOOLEAN
557 myBooleanValue BERPDU ::= TRUE
563 import from TempA all;
565 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
570 if (dec_BER_PDU('A0030101FF'O) == myBooleanValue)
573 {setverdict(pass);} else {setverdict(fail);}
578 Overall verdict: pass
584 .*---------------------------------------------------------------------*
585 :h3. DECODING [0] EXPLICIT BOOLEAN, CER
586 .*---------------------------------------------------------------------*
589 <TC - DECODING [0] EXPLICIT BOOLEAN, CER>
597 BERPDU ::= [0] EXPLICIT BOOLEAN
599 myBooleanValue BERPDU ::= TRUE
605 import from TempA all;
607 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
612 if (dec_BER_PDU('A0800101FF0000'O) == myBooleanValue)
615 {setverdict(pass);} else {setverdict(fail);}
620 Overall verdict: pass
626 .*---------------------------------------------------------------------*
627 :h3. DECODING [0] EXPLICIT BOOLEAN, Long form - short form
628 .*---------------------------------------------------------------------*
631 <TC - DECODING [0] EXPLICIT BOOLEAN, Long form - short form>
639 BERPDU ::= [0] EXPLICIT BOOLEAN
641 myBooleanValue BERPDU ::= TRUE
647 import from TempA all;
649 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
654 if (dec_BER_PDU('A081030101FF'O) == myBooleanValue)
657 {setverdict(pass);} else {setverdict(fail);}
662 Overall verdict: pass
668 .*---------------------------------------------------------------------*
669 :h3. DECODING [0] EXPLICIT BOOLEAN, Long form Long form
670 .*---------------------------------------------------------------------*
673 <TC - DECODING [0] EXPLICIT BOOLEAN, Long form Long form>
681 BERPDU ::= [0] EXPLICIT BOOLEAN
683 myBooleanValue BERPDU ::= TRUE
689 import from TempA all;
691 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
696 if (dec_BER_PDU('A0810401810199'O) == myBooleanValue)
699 {setverdict(pass);} else {setverdict(fail);}
704 Overall verdict: pass
710 .*---------------------------------------------------------------------*
711 :h3. DECODING [PRIVATE 1] EXPLICIT BOOLEAN , DER, Short form - short form
712 .*---------------------------------------------------------------------*
715 <TC - DECODING [PRIVATE 1] EXPLICIT BOOLEAN , DER, Short form - short form>
723 BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN
725 myBooleanValue BERPDU ::= TRUE
731 import from TempA all;
733 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
738 if (dec_BER_PDU('E1030101FF'O) == myBooleanValue)
741 {setverdict(pass);} else {setverdict(fail);}
746 Overall verdict: pass
752 .*---------------------------------------------------------------------*
753 :h3. DECODING [PRIVATE 1] EXPLICIT BOOLEAN, CER
754 .*---------------------------------------------------------------------*
757 <TC - DECODING [PRIVATE 1] EXPLICIT BOOLEAN, CER>
765 BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN
767 myBooleanValue BERPDU ::= TRUE
773 import from TempA all;
775 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
780 if (dec_BER_PDU('E1800101FF0000'O) == myBooleanValue)
783 {setverdict(pass);} else {setverdict(fail);}
788 Overall verdict: pass
794 .*---------------------------------------------------------------------*
795 :h3. DECODING [PRIVATE 1] EXPLICIT BOOLEAN, Long form - short form
796 .*---------------------------------------------------------------------*
799 <TC - DECODING [PRIVATE 1] EXPLICIT BOOLEAN, Long form - short form>
807 BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN
809 myBooleanValue BERPDU ::= TRUE
815 import from TempA all;
817 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
822 if (dec_BER_PDU('E181030101FF'O) == myBooleanValue)
825 {setverdict(pass);} else {setverdict(fail);}
830 Overall verdict: pass
836 .*---------------------------------------------------------------------*
837 :h3. DECODING [PRIVATE 1] EXPLICIT BOOLEAN, Long form Long form
838 .*---------------------------------------------------------------------*
841 <TC - DECODING [PRIVATE 1] EXPLICIT BOOLEAN, Long form Long form>
849 BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN
851 myBooleanValue BERPDU ::= TRUE
857 import from TempA all;
859 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
864 if (dec_BER_PDU('E1810401810199'O) == myBooleanValue)
867 {setverdict(pass);} else {setverdict(fail);}
872 Overall verdict: pass
878 .*---------------------------------------------------------------------*
879 :h3. DECODING [APPLICATION 2] EXPLICIT BOOLEAN , DER, Short form - short form
880 .*---------------------------------------------------------------------*
883 <TC - DECODING [APPLICATION 2] EXPLICIT BOOLEAN , DER, Short form - short form>
891 BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN
893 myBooleanValue BERPDU ::= TRUE
899 import from TempA all;
901 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
906 if (dec_BER_PDU('62030101FF'O) == myBooleanValue)
909 {setverdict(pass);} else {setverdict(fail);}
914 Overall verdict: pass
920 .*---------------------------------------------------------------------*
921 :h3. DECODING [APPLICATION 2] EXPLICIT BOOLEAN, CER
922 .*---------------------------------------------------------------------*
925 <TC - DECODING [APPLICATION 2] EXPLICIT BOOLEAN, CER>
933 BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN
935 myBooleanValue BERPDU ::= TRUE
941 import from TempA all;
943 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
948 if (dec_BER_PDU('62800101FF0000'O) == myBooleanValue)
951 {setverdict(pass);} else {setverdict(fail);}
956 Overall verdict: pass
962 .*---------------------------------------------------------------------*
963 :h3. DECODING [APPLICATION 2] EXPLICIT BOOLEAN, Long form - short form
964 .*---------------------------------------------------------------------*
967 <TC - DECODING [APPLICATION 2] EXPLICIT BOOLEAN, Long form - short form>
975 BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN
977 myBooleanValue BERPDU ::= TRUE
983 import from TempA all;
985 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
990 if (dec_BER_PDU('6281030101FF'O) == myBooleanValue)
993 {setverdict(pass);} else {setverdict(fail);}
998 Overall verdict: pass
1004 .*---------------------------------------------------------------------*
1005 :h3. DECODING [APPLICATION 2] EXPLICIT BOOLEAN, Long form Long form
1006 .*---------------------------------------------------------------------*
1009 <TC - DECODING [APPLICATION 2] EXPLICIT BOOLEAN, Long form Long form>
1017 BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN
1019 myBooleanValue BERPDU ::= TRUE
1025 import from TempA all;
1027 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
1032 if (dec_BER_PDU('62810401810199'O) == myBooleanValue)
1035 {setverdict(pass);} else {setverdict(fail);}
1040 Overall verdict: pass
1046 .*---------------------------------------------------------------------*
1047 :h3. DECODING [0] IMPLICIT BOOLEAN ,Short form CER,DER
1048 .*---------------------------------------------------------------------*
1051 <TC - DECODING [0] IMPLICIT BOOLEAN ,Short form CER,DER>
1059 BERPDU ::= [0] IMPLICIT BOOLEAN
1061 myBooleanValue BERPDU ::= TRUE
1067 import from TempA all;
1069 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
1074 if (dec_BER_PDU('8001FF'O) == myBooleanValue)
1077 {setverdict(pass);} else {setverdict(fail);}
1082 Overall verdict: pass
1088 .*---------------------------------------------------------------------*
1089 :h3. DECODING [0] IMPLICIT BOOLEAN,Long form
1090 .*---------------------------------------------------------------------*
1093 <TC - DECODING [0] IMPLICIT BOOLEAN,Long form>
1101 BERPDU ::= [0] IMPLICIT BOOLEAN
1103 myBooleanValue BERPDU ::= TRUE
1109 import from TempA all;
1111 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
1116 if (dec_BER_PDU('80810133'O) == myBooleanValue)
1119 {setverdict(pass);} else {setverdict(fail);}
1124 Overall verdict: pass
1130 .*---------------------------------------------------------------------*
1131 :h3. DECODING [PRIVATE 1] IMPLICIT BOOLEAN,Short form CER,DER
1132 .*---------------------------------------------------------------------*
1135 <TC - DECODING [PRIVATE 1] IMPLICIT BOOLEAN,Short form CER,DER>
1143 BERPDU ::= [PRIVATE 1] IMPLICIT BOOLEAN
1145 myBooleanValue BERPDU ::= FALSE
1151 import from TempA all;
1153 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
1158 if (dec_BER_PDU('C10100'O) == myBooleanValue)
1161 {setverdict(pass);} else {setverdict(fail);}
1166 Overall verdict: pass
1172 .*---------------------------------------------------------------------*
1173 :h3. DECODING [PRIVATE 1] IMPLICIT BOOLEAN,Long form
1174 .*---------------------------------------------------------------------*
1177 <TC - DECODING [PRIVATE 1] IMPLICIT BOOLEAN,Long form>
1185 BERPDU ::= [PRIVATE 1] IMPLICIT BOOLEAN
1187 myBooleanValue BERPDU ::= TRUE
1193 import from TempA all;
1195 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
1200 if (dec_BER_PDU('C1810105'O) == myBooleanValue)
1203 {setverdict(pass);} else {setverdict(fail);}
1208 Overall verdict: pass
1214 .*---------------------------------------------------------------------*
1215 :h3. DECODING [APPLICATION 2] IMPLICIT BOOLEAN,Short form CER,DER
1216 .*---------------------------------------------------------------------*
1219 <TC - DECODING [APPLICATION 2] IMPLICIT BOOLEAN,Short form CER,DER>
1227 BERPDU ::= [APPLICATION 2] IMPLICIT BOOLEAN
1229 myBooleanValue BERPDU ::= FALSE
1235 import from TempA all;
1237 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
1242 if (dec_BER_PDU('420100'O) == myBooleanValue)
1245 {setverdict(pass);} else {setverdict(fail);}
1250 Overall verdict: pass
1256 .*---------------------------------------------------------------------*
1257 :h3. DECODING [APPLICATION 2] IMPLICIT BOOLEAN,Long form
1258 .*---------------------------------------------------------------------*
1261 <TC - DECODING [APPLICATION 2] IMPLICIT BOOLEAN,Long form>
1269 BERPDU ::= [APPLICATION 2] IMPLICIT BOOLEAN
1271 myBooleanValue BERPDU ::= TRUE
1277 import from TempA all;
1279 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
1284 if (dec_BER_PDU('42810188'O) == myBooleanValue)
1287 {setverdict(pass);} else {setverdict(fail);}
1292 Overall verdict: pass
1298 .*---------------------------------------------------------------------*
1299 :h3. DER + CER encoding of integer (5)
1300 .*---------------------------------------------------------------------*
1303 <TC - DER + CER encoding of integer (5)>
1304 START OF INTEGER SECTION
1317 import from TempA all;
1318 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1319 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1325 if ((enc_DER_PDU(b) == '020105'O)and(enc_CER_PDU(b) == '020105'O)) {setverdict(pass);} else {setverdict(fail);}
1329 Overall verdict: pass
1335 .*---------------------------------------------------------------------*
1336 :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT
1337 .*---------------------------------------------------------------------*
1340 <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT>
1348 BERPDU ::= [0] EXPLICIT INTEGER
1353 import from TempA all;
1354 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1355 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1361 if ((enc_DER_PDU(b) == 'A003020105'O)and(enc_CER_PDU(b) == 'A0800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
1365 Overall verdict: pass
1371 .*---------------------------------------------------------------------*
1372 :h3. DER + CER encoding of integer (5) with PRIVATE TAG, EXPLICIT
1373 .*---------------------------------------------------------------------*
1376 <TC - DER + CER encoding of integer (5) with PRIVATE TAG, EXPLICIT>
1384 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
1389 import from TempA all;
1390 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1391 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1397 if ((enc_DER_PDU(b) == 'E103020105'O)and(enc_CER_PDU(b) == 'E1800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
1401 Overall verdict: pass
1407 .*---------------------------------------------------------------------*
1408 :h3. DER + CER encoding of integer (5) with APPLICATION TAG, EXPLICIT
1409 .*---------------------------------------------------------------------*
1412 <TC - DER + CER encoding of integer (5) with APPLICATION TAG, EXPLICIT>
1420 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
1425 import from TempA all;
1426 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1427 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1433 if ((enc_DER_PDU(b) == '6203020105'O)and(enc_CER_PDU(b) == '62800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
1437 Overall verdict: pass
1443 .*---------------------------------------------------------------------*
1444 :h3. DER + CER encoding of integer (5) with Context Specific TAG, IMPLICIT
1445 .*---------------------------------------------------------------------*
1448 <TC - DER + CER encoding of integer (5) with Context Specific TAG, IMPLICIT>
1456 BERPDU ::= [0] IMPLICIT INTEGER
1461 import from TempA all;
1462 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1463 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1469 if ((enc_DER_PDU(b) == '800105'O)and(enc_CER_PDU(b) == '800105'O)) {setverdict(pass);} else {setverdict(fail);}
1473 Overall verdict: pass
1479 .*---------------------------------------------------------------------*
1480 :h3. DER + CER encoding of integer (5) with PRIVATE TAG, IMPLICIT
1481 .*---------------------------------------------------------------------*
1484 <TC - DER + CER encoding of integer (5) with PRIVATE TAG, IMPLICIT>
1492 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
1497 import from TempA all;
1498 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1499 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1505 if ((enc_DER_PDU(b) == 'C10105'O)and(enc_CER_PDU(b) == 'C10105'O)) {setverdict(pass);} else {setverdict(fail);}
1509 Overall verdict: pass
1515 .*---------------------------------------------------------------------*
1516 :h3. DER + CER encoding of integer (5) with APPLICATION TAG, IMPLICIT
1517 .*---------------------------------------------------------------------*
1520 <TC - DER + CER encoding of integer (5) with APPLICATION TAG, IMPLICIT>
1528 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
1533 import from TempA all;
1534 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1535 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1541 if ((enc_DER_PDU(b) == '420105'O)and(enc_CER_PDU(b) == '420105'O)) {setverdict(pass);} else {setverdict(fail);}
1545 Overall verdict: pass
1551 .*---------------------------------------------------------------------*
1552 :h3. DER + CER encoding of integer (0)
1553 .*---------------------------------------------------------------------*
1556 <TC - DER + CER encoding of integer (0) >
1569 import from TempA all;
1570 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1571 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1577 if ((enc_DER_PDU(b) == '020100'O)and(enc_CER_PDU(b) == '020100'O)) {setverdict(pass);} else {setverdict(fail);}
1581 Overall verdict: pass
1587 .*---------------------------------------------------------------------*
1588 :h3. DER + CER encoding of integer (0) with Context Specific TAG, EXPLICIT
1589 .*---------------------------------------------------------------------*
1592 <TC - DER + CER encoding of integer (0) with Context Specific TAG, EXPLICIT>
1600 BERPDU ::= [0] EXPLICIT INTEGER
1605 import from TempA all;
1606 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1607 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1613 if ((enc_DER_PDU(b) == 'A003020100'O)and(enc_CER_PDU(b) == 'A0800201000000'O)) {setverdict(pass);} else {setverdict(fail);}
1617 Overall verdict: pass
1623 .*---------------------------------------------------------------------*
1624 :h3. DER + CER encoding of integer (0) with PRIVATE TAG, EXPLICIT
1625 .*---------------------------------------------------------------------*
1628 <TC - DER + CER encoding of integer (0) with PRIVATE TAG, EXPLICIT>
1636 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
1641 import from TempA all;
1642 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1643 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1649 if ((enc_DER_PDU(b) == 'E103020100'O)and(enc_CER_PDU(b) == 'E1800201000000'O)) {setverdict(pass);} else {setverdict(fail);}
1653 Overall verdict: pass
1659 .*---------------------------------------------------------------------*
1660 :h3. DER + CER encoding of integer (0) with APPLICATION TAG, EXPLICIT
1661 .*---------------------------------------------------------------------*
1664 <TC - DER + CER encoding of integer (0) with APPLICATION TAG, EXPLICIT>
1672 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
1677 import from TempA all;
1678 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1679 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1685 if ((enc_DER_PDU(b) == '6203020100'O)and(enc_CER_PDU(b) == '62800201000000'O)) {setverdict(pass);} else {setverdict(fail);}
1689 Overall verdict: pass
1695 .*---------------------------------------------------------------------*
1696 :h3. DER + CER encoding of integer (0) with Context Specific TAG, IMPLICIT
1697 .*---------------------------------------------------------------------*
1700 <TC - DER + CER encoding of integer (0) with Context Specific TAG, IMPLICIT>
1708 BERPDU ::= [0] IMPLICIT INTEGER
1713 import from TempA all;
1714 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1715 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1721 if ((enc_DER_PDU(b) == '800100'O)and(enc_CER_PDU(b) == '800100'O)) {setverdict(pass);} else {setverdict(fail);}
1725 Overall verdict: pass
1731 .*---------------------------------------------------------------------*
1732 :h3. DER + CER encoding of integer (0) with PRIVATE TAG, IMPLICIT
1733 .*---------------------------------------------------------------------*
1736 <TC - DER + CER encoding of integer (0) with PRIVATE TAG, IMPLICIT>
1744 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
1749 import from TempA all;
1750 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1751 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1757 if ((enc_DER_PDU(b) == 'C10100'O)and(enc_CER_PDU(b) == 'C10100'O)) {setverdict(pass);} else {setverdict(fail);}
1761 Overall verdict: pass
1767 .*---------------------------------------------------------------------*
1768 :h3. DER + CER encoding of integer (0) with APPLICATION TAG, IMPLICIT
1769 .*---------------------------------------------------------------------*
1772 <TC - DER + CER encoding of integer (0) with APPLICATION TAG, IMPLICIT>
1780 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
1785 import from TempA all;
1786 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1787 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1793 if ((enc_DER_PDU(b) == '420100'O)and(enc_CER_PDU(b) == '420100'O)) {setverdict(pass);} else {setverdict(fail);}
1797 Overall verdict: pass
1803 .*---------------------------------------------------------------------*
1804 :h3. DER + CER encoding of integer (127)
1805 .*---------------------------------------------------------------------*
1808 <TC - DER + CER encoding of integer (127) >
1821 import from TempA all;
1822 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1823 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1825 const BERPDU b := 127
1829 if ((enc_DER_PDU(b) == '02017F'O)and(enc_CER_PDU(b) == '02017F'O)) {setverdict(pass);} else {setverdict(fail);}
1833 Overall verdict: pass
1839 .*---------------------------------------------------------------------*
1840 :h3. DER + CER encoding of integer (127) with Context Specific TAG, EXPLICIT
1841 .*---------------------------------------------------------------------*
1844 <TC - DER + CER encoding of integer (127) with Context Specific TAG, EXPLICIT>
1852 BERPDU ::= [0] EXPLICIT INTEGER
1857 import from TempA all;
1858 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1859 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1861 const BERPDU b := 127
1865 if ((enc_DER_PDU(b) == 'A00302017F'O)and(enc_CER_PDU(b) == 'A08002017F0000'O)) {setverdict(pass);} else {setverdict(fail);}
1869 Overall verdict: pass
1875 .*---------------------------------------------------------------------*
1876 :h3. DER + CER encoding of integer (127) with PRIVATE TAG, EXPLICIT
1877 .*---------------------------------------------------------------------*
1880 <TC - DER + CER encoding of integer (127) with PRIVATE TAG, EXPLICIT>
1888 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
1893 import from TempA all;
1894 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1895 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1897 const BERPDU b := 127
1901 if ((enc_DER_PDU(b) == 'E10302017F'O)and(enc_CER_PDU(b) == 'E18002017F0000'O)) {setverdict(pass);} else {setverdict(fail);}
1905 Overall verdict: pass
1911 .*---------------------------------------------------------------------*
1912 :h3. DER + CER encoding of integer (127) with APPLICATION TAG, EXPLICIT
1913 .*---------------------------------------------------------------------*
1916 <TC - DER + CER encoding of integer (127) with APPLICATION TAG, EXPLICIT>
1924 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
1929 import from TempA all;
1930 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1931 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1933 const BERPDU b := 127
1937 if ((enc_DER_PDU(b) == '620302017F'O)and(enc_CER_PDU(b) == '628002017F0000'O)) {setverdict(pass);} else {setverdict(fail);}
1941 Overall verdict: pass
1947 .*---------------------------------------------------------------------*
1948 :h3. DER + CER encoding of integer (127) with Context Specific TAG, IMPLICIT
1949 .*---------------------------------------------------------------------*
1952 <TC - DER + CER encoding of integer (127) with Context Specific TAG, IMPLICIT>
1960 BERPDU ::= [0] IMPLICIT INTEGER
1965 import from TempA all;
1966 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1967 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
1969 const BERPDU b := 127
1973 if ((enc_DER_PDU(b) == '80017F'O)and(enc_CER_PDU(b) == '80017F'O)) {setverdict(pass);} else {setverdict(fail);}
1977 Overall verdict: pass
1983 .*---------------------------------------------------------------------*
1984 :h3. DER + CER encoding of integer (127) with PRIVATE TAG, IMPLICIT
1985 .*---------------------------------------------------------------------*
1988 <TC - DER + CER encoding of integer (127) with PRIVATE TAG, IMPLICIT>
1996 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
2001 import from TempA all;
2002 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2003 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2005 const BERPDU b := 127
2009 if ((enc_DER_PDU(b) == 'C1017F'O)and(enc_CER_PDU(b) == 'C1017F'O)) {setverdict(pass);} else {setverdict(fail);}
2013 Overall verdict: pass
2019 .*---------------------------------------------------------------------*
2020 :h3. DER + CER encoding of integer (127) with APPLICATION TAG, IMPLICIT
2021 .*---------------------------------------------------------------------*
2024 <TC - DER + CER encoding of integer (127) with APPLICATION TAG, IMPLICIT>
2032 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
2037 import from TempA all;
2038 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2039 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2041 const BERPDU b := 127
2045 if ((enc_DER_PDU(b) == '42017F'O)and(enc_CER_PDU(b) == '42017F'O)) {setverdict(pass);} else {setverdict(fail);}
2049 Overall verdict: pass
2055 .*---------------------------------------------------------------------*
2056 :h3. DER + CER encoding of integer (-128)
2057 .*---------------------------------------------------------------------*
2060 <TC - DER + CER encoding of integer (-128) >
2073 import from TempA all;
2074 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2075 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2077 const BERPDU b := -128
2081 if ((enc_DER_PDU(b) == '020180'O)and(enc_CER_PDU(b) == '020180'O)) {setverdict(pass);} else {setverdict(fail);}
2085 Overall verdict: pass
2091 .*---------------------------------------------------------------------*
2092 :h3. DER + CER encoding of integer (-128) with Context Specific TAG, EXPLICIT
2093 .*---------------------------------------------------------------------*
2096 <TC - DER + CER encoding of integer (-128) with Context Specific TAG, EXPLICIT>
2104 BERPDU ::= [0] EXPLICIT INTEGER
2109 import from TempA all;
2110 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2111 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2113 const BERPDU b := -128
2117 if ((enc_DER_PDU(b) == 'A003020180'O)and(enc_CER_PDU(b) == 'A0800201800000'O)) {setverdict(pass);} else {setverdict(fail);}
2121 Overall verdict: pass
2127 .*---------------------------------------------------------------------*
2128 :h3. DER + CER encoding of integer (-128) with PRIVATE TAG, EXPLICIT
2129 .*---------------------------------------------------------------------*
2132 <TC - DER + CER encoding of integer (-128) with PRIVATE TAG, EXPLICIT>
2140 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
2145 import from TempA all;
2146 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2147 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2149 const BERPDU b := -128
2153 if ((enc_DER_PDU(b) == 'E103020180'O)and(enc_CER_PDU(b) == 'E1800201800000'O)) {setverdict(pass);} else {setverdict(fail);}
2157 Overall verdict: pass
2163 .*---------------------------------------------------------------------*
2164 :h3. DER + CER encoding of integer (-128) with APPLICATION TAG, EXPLICIT
2165 .*---------------------------------------------------------------------*
2168 <TC - DER + CER encoding of integer (-128) with APPLICATION TAG, EXPLICIT>
2176 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
2181 import from TempA all;
2182 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2183 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2185 const BERPDU b := -128
2189 if ((enc_DER_PDU(b) == '6203020180'O)and(enc_CER_PDU(b) == '62800201800000'O)) {setverdict(pass);} else {setverdict(fail);}
2193 Overall verdict: pass
2199 .*---------------------------------------------------------------------*
2200 :h3. DER + CER encoding of integer (-128) with Context Specific TAG, IMPLICIT
2201 .*---------------------------------------------------------------------*
2204 <TC - DER + CER encoding of integer (-128) with Context Specific TAG, IMPLICIT>
2212 BERPDU ::= [0] IMPLICIT INTEGER
2217 import from TempA all;
2218 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2219 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2221 const BERPDU b := -128
2225 if ((enc_DER_PDU(b) == '800180'O)and(enc_CER_PDU(b) == '800180'O)) {setverdict(pass);} else {setverdict(fail);}
2229 Overall verdict: pass
2235 .*---------------------------------------------------------------------*
2236 :h3. DER + CER encoding of integer (-128) with PRIVATE TAG, IMPLICIT
2237 .*---------------------------------------------------------------------*
2240 <TC - DER + CER encoding of integer (-128) with PRIVATE TAG, IMPLICIT>
2248 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
2253 import from TempA all;
2254 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2255 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2257 const BERPDU b := -128
2261 if ((enc_DER_PDU(b) == 'C10180'O)and(enc_CER_PDU(b) == 'C10180'O)) {setverdict(pass);} else {setverdict(fail);}
2265 Overall verdict: pass
2271 .*---------------------------------------------------------------------*
2272 :h3. DER + CER encoding of integer (-128) with APPLICATION TAG, IMPLICIT
2273 .*---------------------------------------------------------------------*
2276 <TC - DER + CER encoding of integer (-128) with APPLICATION TAG, IMPLICIT>
2284 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
2289 import from TempA all;
2290 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2291 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2293 const BERPDU b := -128
2297 if ((enc_DER_PDU(b) == '420180'O)and(enc_CER_PDU(b) == '420180'O)) {setverdict(pass);} else {setverdict(fail);}
2301 Overall verdict: pass
2307 .*---------------------------------------------------------------------*
2308 :h3. DER + CER encoding of integer (-5)
2309 .*---------------------------------------------------------------------*
2312 <TC - DER + CER encoding of integer (-5)>
2325 import from TempA all;
2326 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2327 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2329 const BERPDU b := -5
2333 if ((enc_DER_PDU(b) == '0201FB'O)and(enc_CER_PDU(b) == '0201FB'O)) {setverdict(pass);} else {setverdict(fail);}
2337 Overall verdict: pass
2343 .*---------------------------------------------------------------------*
2344 :h3. DER + CER encoding of integer (-5) with Context Specific TAG, EXPLICIT
2345 .*---------------------------------------------------------------------*
2348 <TC - DER + CER encoding of integer (-5) with Context Specific TAG, EXPLICIT>
2356 BERPDU ::= [0] EXPLICIT INTEGER
2361 import from TempA all;
2362 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2363 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2365 const BERPDU b := -5
2369 if ((enc_DER_PDU(b) == 'A0030201FB'O)and(enc_CER_PDU(b) == 'A0800201FB0000'O)) {setverdict(pass);} else {setverdict(fail);}
2373 Overall verdict: pass
2379 .*---------------------------------------------------------------------*
2380 :h3. DER + CER encoding of integer (-5) with PRIVATE TAG, EXPLICIT
2381 .*---------------------------------------------------------------------*
2384 <TC - DER + CER encoding of integer (-5) with PRIVATE TAG, EXPLICIT>
2392 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
2397 import from TempA all;
2398 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2399 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2401 const BERPDU b := -5
2405 if ((enc_DER_PDU(b) == 'E1030201FB'O)and(enc_CER_PDU(b) == 'E1800201FB0000'O)) {setverdict(pass);} else {setverdict(fail);}
2409 Overall verdict: pass
2415 .*---------------------------------------------------------------------*
2416 :h3. DER + CER encoding of integer (-5) with APPLICATION TAG, EXPLICIT
2417 .*---------------------------------------------------------------------*
2420 <TC - DER + CER encoding of integer (-5) with APPLICATION TAG, EXPLICIT>
2428 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
2433 import from TempA all;
2434 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2435 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2437 const BERPDU b := -5
2441 if ((enc_DER_PDU(b) == '62030201FB'O)and(enc_CER_PDU(b) == '62800201FB0000'O)) {setverdict(pass);} else {setverdict(fail);}
2445 Overall verdict: pass
2451 .*---------------------------------------------------------------------*
2452 :h3. DER + CER encoding of integer (-5) with Context Specific TAG, IMPLICIT
2453 .*---------------------------------------------------------------------*
2456 <TC - DER + CER encoding of integer (-5) with Context Specific TAG, IMPLICIT>
2464 BERPDU ::= [0] IMPLICIT INTEGER
2469 import from TempA all;
2470 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2471 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2473 const BERPDU b := -5
2477 if ((enc_DER_PDU(b) == '8001FB'O)and(enc_CER_PDU(b) == '8001FB'O)) {setverdict(pass);} else {setverdict(fail);}
2481 Overall verdict: pass
2487 .*---------------------------------------------------------------------*
2488 :h3. DER + CER encoding of integer (-5) with PRIVATE TAG, IMPLICIT
2489 .*---------------------------------------------------------------------*
2492 <TC - DER + CER encoding of integer (-5) with PRIVATE TAG, IMPLICIT>
2500 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
2505 import from TempA all;
2506 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2507 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2509 const BERPDU b := -5
2513 if ((enc_DER_PDU(b) == 'C101FB'O)and(enc_CER_PDU(b) == 'C101FB'O)) {setverdict(pass);} else {setverdict(fail);}
2517 Overall verdict: pass
2523 .*---------------------------------------------------------------------*
2524 :h3. DER + CER encoding of integer (-5) with APPLICATION TAG, IMPLICIT
2525 .*---------------------------------------------------------------------*
2528 <TC - DER + CER encoding of integer (-5) with APPLICATION TAG, IMPLICIT>
2536 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
2541 import from TempA all;
2542 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2543 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2545 const BERPDU b := -5
2549 if ((enc_DER_PDU(b) == '4201FB'O)and(enc_CER_PDU(b) == '4201FB'O)) {setverdict(pass);} else {setverdict(fail);}
2553 Overall verdict: pass
2559 .*---------------------------------------------------------------------*
2560 :h3. DER + CER encoding of integer (128)
2561 .*---------------------------------------------------------------------*
2564 <TC - DER + CER encoding of integer (128)>
2577 import from TempA all;
2578 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2579 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2581 const BERPDU b := 128
2585 if ((enc_DER_PDU(b) == '02020080'O)and(enc_CER_PDU(b) == '02020080'O)) {setverdict(pass);} else {setverdict(fail);}
2589 Overall verdict: pass
2595 .*---------------------------------------------------------------------*
2596 :h3. DER + CER encoding of integer (128) with Context Specific TAG, EXPLICIT
2597 .*---------------------------------------------------------------------*
2600 <TC - DER + CER encoding of integer (128) with Context Specific TAG, EXPLICIT>
2608 BERPDU ::= [0] EXPLICIT INTEGER
2613 import from TempA all;
2614 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2615 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2617 const BERPDU b := 128
2621 if ((enc_DER_PDU(b) == 'A00402020080'O)and(enc_CER_PDU(b) == 'A080020200800000'O)) {setverdict(pass);} else {setverdict(fail);}
2625 Overall verdict: pass
2631 .*---------------------------------------------------------------------*
2632 :h3. DER + CER encoding of integer (128) with PRIVATE TAG, EXPLICIT
2633 .*---------------------------------------------------------------------*
2636 <TC - DER + CER encoding of integer (128) with PRIVATE TAG, EXPLICIT>
2644 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
2649 import from TempA all;
2650 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2651 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2653 const BERPDU b := 128
2657 if ((enc_DER_PDU(b) == 'E10402020080'O)and(enc_CER_PDU(b) == 'E180020200800000'O)) {setverdict(pass);} else {setverdict(fail);}
2661 Overall verdict: pass
2667 .*---------------------------------------------------------------------*
2668 :h3. DER + CER encoding of integer (128) with APPLICATION TAG, EXPLICIT
2669 .*---------------------------------------------------------------------*
2672 <TC - DER + CER encoding of integer (128) with APPLICATION TAG, EXPLICIT>
2680 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
2685 import from TempA all;
2686 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2687 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2689 const BERPDU b := 128
2693 if ((enc_DER_PDU(b) == '620402020080'O)and(enc_CER_PDU(b) == '6280020200800000'O)) {setverdict(pass);} else {setverdict(fail);}
2697 Overall verdict: pass
2703 .*---------------------------------------------------------------------*
2704 :h3. DER + CER encoding of integer (128) with Context Specific TAG, IMPLICIT
2705 .*---------------------------------------------------------------------*
2708 <TC - DER + CER encoding of integer (128) with Context Specific TAG, IMPLICIT>
2716 BERPDU ::= [0] IMPLICIT INTEGER
2721 import from TempA all;
2722 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2723 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2725 const BERPDU b := 128
2729 if ((enc_DER_PDU(b) == '80020080'O)and(enc_CER_PDU(b) == '80020080'O)) {setverdict(pass);} else {setverdict(fail);}
2733 Overall verdict: pass
2739 .*---------------------------------------------------------------------*
2740 :h3. DER + CER encoding of integer (128) with PRIVATE TAG, IMPLICIT
2741 .*---------------------------------------------------------------------*
2744 <TC - DER + CER encoding of integer (128) with PRIVATE TAG, IMPLICIT>
2752 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
2757 import from TempA all;
2758 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2759 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2761 const BERPDU b := 128
2765 if ((enc_DER_PDU(b) == 'C1020080'O)and(enc_CER_PDU(b) == 'C1020080'O)) {setverdict(pass);} else {setverdict(fail);}
2769 Overall verdict: pass
2775 .*---------------------------------------------------------------------*
2776 :h3. DER + CER encoding of integer (128) with APPLICATION TAG, IMPLICIT
2777 .*---------------------------------------------------------------------*
2780 <TC - DER + CER encoding of integer (128) with APPLICATION TAG, IMPLICIT>
2788 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
2793 import from TempA all;
2794 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2795 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2797 const BERPDU b := 128
2801 if ((enc_DER_PDU(b) == '42020080'O)and(enc_CER_PDU(b) == '42020080'O)) {setverdict(pass);} else {setverdict(fail);}
2805 Overall verdict: pass
2811 .*---------------------------------------------------------------------*
2812 :h3. DER + CER encoding of integer (-129)
2813 .*---------------------------------------------------------------------*
2816 <TC - DER + CER encoding of integer (-129)>
2829 import from TempA all;
2830 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2831 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2833 const BERPDU b := -129
2837 if ((enc_DER_PDU(b) == '0202FF7F'O)and(enc_CER_PDU(b) == '0202FF7F'O)) {setverdict(pass);} else {setverdict(fail);}
2841 Overall verdict: pass
2847 .*---------------------------------------------------------------------*
2848 :h3. DER + CER encoding of integer (-129) with Context Specific TAG, EXPLICIT
2849 .*---------------------------------------------------------------------*
2852 <TC - DER + CER encoding of integer (-129) with Context Specific TAG, EXPLICIT>
2860 BERPDU ::= [0] EXPLICIT INTEGER
2865 import from TempA all;
2866 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2867 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2869 const BERPDU b := -129
2873 if ((enc_DER_PDU(b) == 'A0040202FF7F'O)and(enc_CER_PDU(b) == 'A0800202FF7F0000'O)) {setverdict(pass);} else {setverdict(fail);}
2877 Overall verdict: pass
2883 .*---------------------------------------------------------------------*
2884 :h3. DER + CER encoding of integer (-129) with PRIVATE TAG, EXPLICIT
2885 .*---------------------------------------------------------------------*
2888 <TC - DER + CER encoding of integer (-129) with PRIVATE TAG, EXPLICIT>
2896 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
2901 import from TempA all;
2902 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2903 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2905 const BERPDU b := -129
2909 if ((enc_DER_PDU(b) == 'E1040202FF7F'O)and(enc_CER_PDU(b) == 'E1800202FF7F0000'O)) {setverdict(pass);} else {setverdict(fail);}
2913 Overall verdict: pass
2919 .*---------------------------------------------------------------------*
2920 :h3. DER + CER encoding of integer (-129) with APPLICATION TAG, EXPLICIT
2921 .*---------------------------------------------------------------------*
2924 <TC - DER + CER encoding of integer (-129) with APPLICATION TAG, EXPLICIT>
2932 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
2937 import from TempA all;
2938 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2939 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2941 const BERPDU b := -129
2945 if ((enc_DER_PDU(b) == '62040202FF7F'O)and(enc_CER_PDU(b) == '62800202FF7F0000'O)) {setverdict(pass);} else {setverdict(fail);}
2949 Overall verdict: pass
2955 .*---------------------------------------------------------------------*
2956 :h3. DER + CER encoding of integer (-129) with Context Specific TAG, IMPLICIT
2957 .*---------------------------------------------------------------------*
2960 <TC - DER + CER encoding of integer (-129) with Context Specific TAG, IMPLICIT>
2968 BERPDU ::= [0] IMPLICIT INTEGER
2973 import from TempA all;
2974 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
2975 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
2977 const BERPDU b := -129
2981 if ((enc_DER_PDU(b) == '8002FF7F'O)and(enc_CER_PDU(b) == '8002FF7F'O)) {setverdict(pass);} else {setverdict(fail);}
2985 Overall verdict: pass
2991 .*---------------------------------------------------------------------*
2992 :h3. DER + CER encoding of integer (-129) with PRIVATE TAG, IMPLICIT
2993 .*---------------------------------------------------------------------*
2996 <TC - DER + CER encoding of integer (-129) with PRIVATE TAG, IMPLICIT>
3004 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
3009 import from TempA all;
3010 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3011 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3013 const BERPDU b := -129
3017 if ((enc_DER_PDU(b) == 'C102FF7F'O)and(enc_CER_PDU(b) == 'C102FF7F'O)) {setverdict(pass);} else {setverdict(fail);}
3021 Overall verdict: pass
3027 .*---------------------------------------------------------------------*
3028 :h3. DER + CER encoding of integer (-129) with APPLICATION TAG, IMPLICIT
3029 .*---------------------------------------------------------------------*
3032 <TC - DER + CER encoding of integer (-129) with APPLICATION TAG, IMPLICIT>
3040 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
3045 import from TempA all;
3046 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3047 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3049 const BERPDU b := -129
3053 if ((enc_DER_PDU(b) == '4202FF7F'O)and(enc_CER_PDU(b) == '4202FF7F'O)) {setverdict(pass);} else {setverdict(fail);}
3057 Overall verdict: pass
3063 .*---------------------------------------------------------------------*
3064 :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT
3065 .*---------------------------------------------------------------------*
3068 <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT>
3078 BERPDU ::= [30] EXPLICIT INTEGER
3083 import from TempA all;
3084 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3085 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3091 if ((enc_DER_PDU(b) == 'BE03020105'O)and(enc_CER_PDU(b) == 'BE800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
3095 Overall verdict: pass
3101 .*---------------------------------------------------------------------*
3102 :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT
3103 .*---------------------------------------------------------------------*
3106 <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT>
3116 BERPDU ::= [31] EXPLICIT INTEGER
3121 import from TempA all;
3122 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3123 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3129 if ((enc_DER_PDU(b) == 'BF1F03020105'O)and(enc_CER_PDU(b) == 'BF1F800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
3133 Overall verdict: pass
3139 .*---------------------------------------------------------------------*
3140 :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT
3141 .*---------------------------------------------------------------------*
3144 <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT>
3154 BERPDU ::= [127] EXPLICIT INTEGER
3159 import from TempA all;
3160 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3161 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3167 if ((enc_DER_PDU(b) == 'BF7F03020105'O)and(enc_CER_PDU(b) == 'BF7F800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
3171 Overall verdict: pass
3177 .*---------------------------------------------------------------------*
3178 :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT
3179 .*---------------------------------------------------------------------*
3182 <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT>
3192 BERPDU ::= [128] EXPLICIT INTEGER
3197 import from TempA all;
3198 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3199 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3205 if ((enc_DER_PDU(b) == 'BF810003020105'O)and(enc_CER_PDU(b) == 'BF8100800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
3209 Overall verdict: pass
3215 .*---------------------------------------------------------------------*
3216 :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT
3217 .*---------------------------------------------------------------------*
3220 <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT>
3230 BERPDU ::= [16383] EXPLICIT INTEGER
3235 import from TempA all;
3236 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3237 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3243 if ((enc_DER_PDU(b) == 'BFFF7F03020105'O)and(enc_CER_PDU(b) == 'BFFF7F800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
3247 Overall verdict: pass
3253 .*---------------------------------------------------------------------*
3254 :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT
3255 .*---------------------------------------------------------------------*
3258 <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT>
3268 BERPDU ::= [16384] EXPLICIT INTEGER
3273 import from TempA all;
3274 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
3275 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
3281 if ((enc_DER_PDU(b) == 'BF81800003020105'O)and(enc_CER_PDU(b) == 'BF818000800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
3285 Overall verdict: pass
3291 .*---------------------------------------------------------------------*
3292 :h3. DECODING INTEGER (5), CER+DER
3293 .*---------------------------------------------------------------------*
3296 <TC - DECODING INTEGER (5), CER+DER>
3306 myIntegerValue BERPDU ::= 5
3312 import from TempA all;
3314 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3319 if (dec_BER_PDU('020105'O) == myIntegerValue)
3322 {setverdict(pass);} else {setverdict(fail);}
3327 Overall verdict: pass
3333 .*---------------------------------------------------------------------*
3334 :h3. DECODING INTEGER (5), (LENGTH OF LENGTH = 1)
3335 .*---------------------------------------------------------------------*
3338 <TC - DECODING INTEGER (5), (LENGTH OF LENGTH = 1)>
3348 myIntegerValue BERPDU ::= 5
3354 import from TempA all;
3356 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3361 if (dec_BER_PDU('02810105'O) == myIntegerValue)
3364 {setverdict(pass);} else {setverdict(fail);}
3369 Overall verdict: pass
3375 .*---------------------------------------------------------------------*
3376 :h3. DECODING INTEGER (5), (LENGTH OF LENGTH = 2)
3377 .*---------------------------------------------------------------------*
3380 <TC - DECODING INTEGER (5), (LENGTH OF LENGTH = 2)>
3390 myIntegerValue BERPDU ::= 5
3396 import from TempA all;
3398 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3403 if (dec_BER_PDU('0282000105'O) == myIntegerValue)
3406 {setverdict(pass);} else {setverdict(fail);}
3411 Overall verdict: pass
3417 .*---------------------------------------------------------------------*
3418 :h3. DECODING [0] EXPLICIT INTEGER (5), DER
3419 .*---------------------------------------------------------------------*
3422 <TC - DECODING [0] EXPLICIT INTEGER (5), DER>
3430 BERPDU ::= [0] EXPLICIT INTEGER
3432 myIntegerValue BERPDU ::= 5
3438 import from TempA all;
3440 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3445 if (dec_BER_PDU('A003020105'O) == myIntegerValue)
3448 {setverdict(pass);} else {setverdict(fail);}
3453 Overall verdict: pass
3459 .*---------------------------------------------------------------------*
3460 :h3. DECODING [0] EXPLICIT INTEGER (5), CER
3461 .*---------------------------------------------------------------------*
3464 <TC - DECODING [0] EXPLICIT INTEGER (5), CER>
3472 BERPDU ::= [0] EXPLICIT INTEGER
3474 myIntegerValue BERPDU ::= 5
3480 import from TempA all;
3482 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3487 if (dec_BER_PDU('A0800201050000'O) == myIntegerValue)
3490 {setverdict(pass);} else {setverdict(fail);}
3495 Overall verdict: pass
3501 .*---------------------------------------------------------------------*
3502 :h3. DECODING [0] EXPLICIT INTEGER (5), Short form - long form
3503 .*---------------------------------------------------------------------*
3506 <TC - DECODING [0] EXPLICIT INTEGER (5), Short form - long form>
3514 BERPDU ::= [0] EXPLICIT INTEGER
3516 myIntegerValue BERPDU ::= 5
3522 import from TempA all;
3524 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3529 if (dec_BER_PDU('A003020105'O) == myIntegerValue)
3532 {setverdict(pass);} else {setverdict(fail);}
3537 Overall verdict: pass
3543 .*---------------------------------------------------------------------*
3544 :h3. DECODING [0] EXPLICIT INTEGER (5), Long form - short form
3545 .*---------------------------------------------------------------------*
3548 <TC - DECODING [0] EXPLICIT INTEGER (5), Long form - short form>
3556 BERPDU ::= [0] EXPLICIT INTEGER
3558 myIntegerValue BERPDU ::= 5
3564 import from TempA all;
3566 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3571 if (dec_BER_PDU('A08103020105'O) == myIntegerValue)
3574 {setverdict(pass);} else {setverdict(fail);}
3579 Overall verdict: pass
3585 .*---------------------------------------------------------------------*
3586 :h3. DECODING [0] EXPLICIT INTEGER (5), Long form Long form
3587 .*---------------------------------------------------------------------*
3590 <TC - DECODING [0] EXPLICIT INTEGER (5), Long form Long form>
3598 BERPDU ::= [0] EXPLICIT INTEGER
3600 myIntegerValue BERPDU ::= 5
3606 import from TempA all;
3608 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3613 if (dec_BER_PDU('A0810402810105'O) == myIntegerValue)
3616 {setverdict(pass);} else {setverdict(fail);}
3621 Overall verdict: pass
3627 .*---------------------------------------------------------------------*
3628 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Short form - Short form, DER
3629 .*---------------------------------------------------------------------*
3632 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Short form - Short form, DER>
3640 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
3642 myIntegerValue BERPDU ::= 5
3648 import from TempA all;
3650 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3655 if (dec_BER_PDU('E103020105'O) == myIntegerValue)
3658 {setverdict(pass);} else {setverdict(fail);}
3663 Overall verdict: pass
3669 .*---------------------------------------------------------------------*
3670 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Short form - long form
3671 .*---------------------------------------------------------------------*
3674 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Short form - long form>
3682 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
3684 myIntegerValue BERPDU ::= 5
3690 import from TempA all;
3692 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3697 if (dec_BER_PDU('E10402810105'O) == myIntegerValue)
3700 {setverdict(pass);} else {setverdict(fail);}
3705 Overall verdict: pass
3711 .*---------------------------------------------------------------------*
3712 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Long form - short form
3713 .*---------------------------------------------------------------------*
3716 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Long form - short form>
3724 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
3726 myIntegerValue BERPDU ::= 5
3732 import from TempA all;
3734 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3739 if (dec_BER_PDU('E18103020105'O) == myIntegerValue)
3742 {setverdict(pass);} else {setverdict(fail);}
3747 Overall verdict: pass
3753 .*---------------------------------------------------------------------*
3754 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Long form Long form
3755 .*---------------------------------------------------------------------*
3758 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Long form Long form>
3766 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
3768 myIntegerValue BERPDU ::= 5
3774 import from TempA all;
3776 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3781 if (dec_BER_PDU('E1810402810105'O) == myIntegerValue)
3784 {setverdict(pass);} else {setverdict(fail);}
3789 Overall verdict: pass
3795 .*---------------------------------------------------------------------*
3796 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5),Indefinite form,CER
3797 .*---------------------------------------------------------------------*
3800 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5),Indefinite form,CER>
3808 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
3810 myIntegerValue BERPDU ::= 5
3816 import from TempA all;
3818 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3823 if (dec_BER_PDU('E1800201050000'O) == myIntegerValue)
3826 {setverdict(pass);} else {setverdict(fail);}
3831 Overall verdict: pass
3837 .*---------------------------------------------------------------------*
3838 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Short form - Short form, DER
3839 .*---------------------------------------------------------------------*
3842 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Short form - Short form, DER>
3850 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
3852 myIntegerValue BERPDU ::= 5
3858 import from TempA all;
3860 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3865 if (dec_BER_PDU('6203020105'O) == myIntegerValue)
3868 {setverdict(pass);} else {setverdict(fail);}
3873 Overall verdict: pass
3879 .*---------------------------------------------------------------------*
3880 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Short form - long form
3881 .*---------------------------------------------------------------------*
3884 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Short form - long form>
3892 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
3894 myIntegerValue BERPDU ::= 5
3900 import from TempA all;
3902 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3907 if (dec_BER_PDU('620402810105'O) == myIntegerValue)
3910 {setverdict(pass);} else {setverdict(fail);}
3915 Overall verdict: pass
3921 .*---------------------------------------------------------------------*
3922 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Long form - short form
3923 .*---------------------------------------------------------------------*
3926 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Long form - short form>
3934 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
3936 myIntegerValue BERPDU ::= 5
3942 import from TempA all;
3944 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3949 if (dec_BER_PDU('628103020105'O) == myIntegerValue)
3952 {setverdict(pass);} else {setverdict(fail);}
3957 Overall verdict: pass
3963 .*---------------------------------------------------------------------*
3964 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Long form Long form
3965 .*---------------------------------------------------------------------*
3968 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Long form Long form>
3976 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
3978 myIntegerValue BERPDU ::= 5
3984 import from TempA all;
3986 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
3991 if (dec_BER_PDU('62810402810105'O) == myIntegerValue)
3994 {setverdict(pass);} else {setverdict(fail);}
3999 Overall verdict: pass
4005 .*---------------------------------------------------------------------*
4006 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5),Indefinite form,CER
4007 .*---------------------------------------------------------------------*
4010 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5),Indefinite form,CER>
4018 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
4020 myIntegerValue BERPDU ::= 5
4026 import from TempA all;
4028 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4033 if (dec_BER_PDU('62800201050000'O) == myIntegerValue)
4036 {setverdict(pass);} else {setverdict(fail);}
4041 Overall verdict: pass
4047 .*---------------------------------------------------------------------*
4048 :h3. DECODING [0] IMPLICIT INTEGER (5),Short form CER,DER
4049 .*---------------------------------------------------------------------*
4052 <TC - DECODING [0] IMPLICIT INTEGER (5),Short form CER,DER>
4060 BERPDU ::= [0] IMPLICIT INTEGER
4062 myIntegerValue BERPDU ::= 5
4068 import from TempA all;
4070 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4075 if (dec_BER_PDU('800105'O) == myIntegerValue)
4078 {setverdict(pass);} else {setverdict(fail);}
4083 Overall verdict: pass
4089 .*---------------------------------------------------------------------*
4090 :h3. DECODING [0] IMPLICIT INTEGER (5),Long form
4091 .*---------------------------------------------------------------------*
4094 <TC - DECODING [0] IMPLICIT INTEGER (5),Long form>
4102 BERPDU ::= [0] IMPLICIT INTEGER
4104 myIntegerValue BERPDU ::= 5
4110 import from TempA all;
4112 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4117 if (dec_BER_PDU('80810105'O) == myIntegerValue)
4120 {setverdict(pass);} else {setverdict(fail);}
4125 Overall verdict: pass
4131 .*---------------------------------------------------------------------*
4132 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (5),Short form CER,DER
4133 .*---------------------------------------------------------------------*
4136 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (5),Short form CER,DER>
4144 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
4146 myIntegerValue BERPDU ::= 5
4152 import from TempA all;
4154 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4159 if (dec_BER_PDU('C10105'O) == myIntegerValue)
4162 {setverdict(pass);} else {setverdict(fail);}
4167 Overall verdict: pass
4173 .*---------------------------------------------------------------------*
4174 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (5),Long form
4175 .*---------------------------------------------------------------------*
4178 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (5),Long form>
4186 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
4188 myIntegerValue BERPDU ::= 5
4194 import from TempA all;
4196 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4201 if (dec_BER_PDU('C1810105'O) == myIntegerValue)
4204 {setverdict(pass);} else {setverdict(fail);}
4209 Overall verdict: pass
4215 .*---------------------------------------------------------------------*
4216 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (5),Short form CER,DER
4217 .*---------------------------------------------------------------------*
4220 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (5),Short form CER,DER>
4228 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
4230 myIntegerValue BERPDU ::= 5
4236 import from TempA all;
4238 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4243 if (dec_BER_PDU('420105'O) == myIntegerValue)
4246 {setverdict(pass);} else {setverdict(fail);}
4251 Overall verdict: pass
4257 .*---------------------------------------------------------------------*
4258 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (5),Long form
4259 .*---------------------------------------------------------------------*
4262 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (5),Long form>
4270 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
4272 myIntegerValue BERPDU ::= 5
4278 import from TempA all;
4280 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4285 if (dec_BER_PDU('42810105'O) == myIntegerValue)
4288 {setverdict(pass);} else {setverdict(fail);}
4293 Overall verdict: pass
4299 .*---------------------------------------------------------------------*
4300 :h3. DECODING INTEGER (0), CER+DER
4301 .*---------------------------------------------------------------------*
4304 <TC - DECODING INTEGER (0), CER+DER>
4314 myIntegerValue BERPDU ::= 0
4320 import from TempA all;
4322 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4327 if (dec_BER_PDU('020100'O) == myIntegerValue)
4330 {setverdict(pass);} else {setverdict(fail);}
4335 Overall verdict: pass
4341 .*---------------------------------------------------------------------*
4342 :h3. DECODING INTEGER (0), (LENGTH OF LENGTH = 1)
4343 .*---------------------------------------------------------------------*
4346 <TC - DECODING INTEGER (0), (LENGTH OF LENGTH = 1)>
4356 myIntegerValue BERPDU ::= 0
4362 import from TempA all;
4364 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4369 if (dec_BER_PDU('02810100'O) == myIntegerValue)
4372 {setverdict(pass);} else {setverdict(fail);}
4377 Overall verdict: pass
4383 .*---------------------------------------------------------------------*
4384 :h3. DECODING INTEGER (0), (LENGTH OF LENGTH = 2)
4385 .*---------------------------------------------------------------------*
4388 <TC - DECODING INTEGER (0), (LENGTH OF LENGTH = 2)>
4398 myIntegerValue BERPDU ::= 0
4404 import from TempA all;
4406 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4411 if (dec_BER_PDU('0282000100'O) == myIntegerValue)
4414 {setverdict(pass);} else {setverdict(fail);}
4419 Overall verdict: pass
4425 .*---------------------------------------------------------------------*
4426 :h3. DECODING [0] EXPLICIT INTEGER (0), DER
4427 .*---------------------------------------------------------------------*
4430 <TC - DECODING [0] EXPLICIT INTEGER (0), DER>
4438 BERPDU ::= [0] EXPLICIT INTEGER
4440 myIntegerValue BERPDU ::= 0
4446 import from TempA all;
4448 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4453 if (dec_BER_PDU('A003020100'O) == myIntegerValue)
4456 {setverdict(pass);} else {setverdict(fail);}
4461 Overall verdict: pass
4467 .*---------------------------------------------------------------------*
4468 :h3. DECODING [0] EXPLICIT INTEGER (0), CER
4469 .*---------------------------------------------------------------------*
4472 <TC - DECODING [0] EXPLICIT INTEGER (0), CER>
4480 BERPDU ::= [0] EXPLICIT INTEGER
4482 myIntegerValue BERPDU ::= 0
4488 import from TempA all;
4490 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4495 if (dec_BER_PDU('A0800201000000'O) == myIntegerValue)
4498 {setverdict(pass);} else {setverdict(fail);}
4503 Overall verdict: pass
4509 .*---------------------------------------------------------------------*
4510 :h3. DECODING [0] EXPLICIT INTEGER (0), Short form - long form
4511 .*---------------------------------------------------------------------*
4514 <TC - DECODING [0] EXPLICIT INTEGER (0), Short form - long form>
4522 BERPDU ::= [0] EXPLICIT INTEGER
4524 myIntegerValue BERPDU ::= 0
4530 import from TempA all;
4532 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4537 if (dec_BER_PDU('A003020100'O) == myIntegerValue)
4540 {setverdict(pass);} else {setverdict(fail);}
4545 Overall verdict: pass
4551 .*---------------------------------------------------------------------*
4552 :h3. DECODING [0] EXPLICIT INTEGER (0), Long form - short form
4553 .*---------------------------------------------------------------------*
4556 <TC - DECODING [0] EXPLICIT INTEGER (0), Long form - short form>
4564 BERPDU ::= [0] EXPLICIT INTEGER
4566 myIntegerValue BERPDU ::= 0
4572 import from TempA all;
4574 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4579 if (dec_BER_PDU('A08103020100'O) == myIntegerValue)
4582 {setverdict(pass);} else {setverdict(fail);}
4587 Overall verdict: pass
4593 .*---------------------------------------------------------------------*
4594 :h3. DECODING [0] EXPLICIT INTEGER (0), Long form Long form
4595 .*---------------------------------------------------------------------*
4598 <TC - DECODING [0] EXPLICIT INTEGER (0), Long form Long form>
4606 BERPDU ::= [0] EXPLICIT INTEGER
4608 myIntegerValue BERPDU ::= 0
4614 import from TempA all;
4616 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4621 if (dec_BER_PDU('A0810402810100'O) == myIntegerValue)
4624 {setverdict(pass);} else {setverdict(fail);}
4629 Overall verdict: pass
4635 .*---------------------------------------------------------------------*
4636 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Short form - Short form, DER
4637 .*---------------------------------------------------------------------*
4640 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Short form - Short form, DER>
4648 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
4650 myIntegerValue BERPDU ::= 0
4656 import from TempA all;
4658 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4663 if (dec_BER_PDU('E103020100'O) == myIntegerValue)
4666 {setverdict(pass);} else {setverdict(fail);}
4671 Overall verdict: pass
4677 .*---------------------------------------------------------------------*
4678 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Short form - long form
4679 .*---------------------------------------------------------------------*
4682 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Short form - long form>
4690 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
4692 myIntegerValue BERPDU ::= 0
4698 import from TempA all;
4700 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4705 if (dec_BER_PDU('E10402810100'O) == myIntegerValue)
4708 {setverdict(pass);} else {setverdict(fail);}
4713 Overall verdict: pass
4719 .*---------------------------------------------------------------------*
4720 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Long form - short form
4721 .*---------------------------------------------------------------------*
4724 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Long form - short form>
4732 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
4734 myIntegerValue BERPDU ::= 0
4740 import from TempA all;
4742 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4747 if (dec_BER_PDU('E18103020100'O) == myIntegerValue)
4750 {setverdict(pass);} else {setverdict(fail);}
4755 Overall verdict: pass
4761 .*---------------------------------------------------------------------*
4762 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Long form Long form
4763 .*---------------------------------------------------------------------*
4766 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Long form Long form>
4774 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
4776 myIntegerValue BERPDU ::= 0
4782 import from TempA all;
4784 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4789 if (dec_BER_PDU('E1810402810100'O) == myIntegerValue)
4792 {setverdict(pass);} else {setverdict(fail);}
4797 Overall verdict: pass
4803 .*---------------------------------------------------------------------*
4804 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0),Indefinite form,CER
4805 .*---------------------------------------------------------------------*
4808 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0),Indefinite form,CER>
4816 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
4818 myIntegerValue BERPDU ::= 0
4824 import from TempA all;
4826 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4831 if (dec_BER_PDU('E1800201000000'O) == myIntegerValue)
4834 {setverdict(pass);} else {setverdict(fail);}
4839 Overall verdict: pass
4845 .*---------------------------------------------------------------------*
4846 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Short form - Short form, DER
4847 .*---------------------------------------------------------------------*
4850 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Short form - Short form, DER>
4858 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
4860 myIntegerValue BERPDU ::= 0
4866 import from TempA all;
4868 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4873 if (dec_BER_PDU('6203020100'O) == myIntegerValue)
4876 {setverdict(pass);} else {setverdict(fail);}
4881 Overall verdict: pass
4887 .*---------------------------------------------------------------------*
4888 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Short form - long form
4889 .*---------------------------------------------------------------------*
4892 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Short form - long form>
4900 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
4902 myIntegerValue BERPDU ::= 0
4908 import from TempA all;
4910 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4915 if (dec_BER_PDU('620402810100'O) == myIntegerValue)
4918 {setverdict(pass);} else {setverdict(fail);}
4923 Overall verdict: pass
4929 .*---------------------------------------------------------------------*
4930 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Long form - short form
4931 .*---------------------------------------------------------------------*
4934 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Long form - short form>
4942 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
4944 myIntegerValue BERPDU ::= 0
4950 import from TempA all;
4952 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4957 if (dec_BER_PDU('628103020100'O) == myIntegerValue)
4960 {setverdict(pass);} else {setverdict(fail);}
4965 Overall verdict: pass
4971 .*---------------------------------------------------------------------*
4972 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Long form Long form
4973 .*---------------------------------------------------------------------*
4976 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Long form Long form>
4984 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
4986 myIntegerValue BERPDU ::= 0
4992 import from TempA all;
4994 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
4999 if (dec_BER_PDU('62810402810100'O) == myIntegerValue)
5002 {setverdict(pass);} else {setverdict(fail);}
5007 Overall verdict: pass
5013 .*---------------------------------------------------------------------*
5014 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0),Indefinite form,CER
5015 .*---------------------------------------------------------------------*
5018 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0),Indefinite form,CER>
5026 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
5028 myIntegerValue BERPDU ::= 0
5034 import from TempA all;
5036 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5041 if (dec_BER_PDU('62800201000000'O) == myIntegerValue)
5044 {setverdict(pass);} else {setverdict(fail);}
5049 Overall verdict: pass
5055 .*---------------------------------------------------------------------*
5056 :h3. DECODING [0] IMPLICIT INTEGER (0),Short form CER,DER
5057 .*---------------------------------------------------------------------*
5060 <TC - DECODING [0] IMPLICIT INTEGER (0),Short form CER,DER>
5068 BERPDU ::= [0] IMPLICIT INTEGER
5070 myIntegerValue BERPDU ::= 0
5076 import from TempA all;
5078 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5083 if (dec_BER_PDU('800100'O) == myIntegerValue)
5086 {setverdict(pass);} else {setverdict(fail);}
5091 Overall verdict: pass
5097 .*---------------------------------------------------------------------*
5098 :h3. DECODING [0] IMPLICIT INTEGER (0),Long form
5099 .*---------------------------------------------------------------------*
5102 <TC - DECODING [0] IMPLICIT INTEGER (0),Long form>
5110 BERPDU ::= [0] IMPLICIT INTEGER
5112 myIntegerValue BERPDU ::= 0
5118 import from TempA all;
5120 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5125 if (dec_BER_PDU('80810100'O) == myIntegerValue)
5128 {setverdict(pass);} else {setverdict(fail);}
5133 Overall verdict: pass
5139 .*---------------------------------------------------------------------*
5140 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (0),Short form CER,DER
5141 .*---------------------------------------------------------------------*
5144 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (0),Short form CER,DER>
5152 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
5154 myIntegerValue BERPDU ::= 0
5160 import from TempA all;
5162 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5167 if (dec_BER_PDU('C10100'O) == myIntegerValue)
5170 {setverdict(pass);} else {setverdict(fail);}
5175 Overall verdict: pass
5181 .*---------------------------------------------------------------------*
5182 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (0),Long form
5183 .*---------------------------------------------------------------------*
5186 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (0),Long form>
5194 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
5196 myIntegerValue BERPDU ::= 0
5202 import from TempA all;
5204 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5209 if (dec_BER_PDU('C1810100'O) == myIntegerValue)
5212 {setverdict(pass);} else {setverdict(fail);}
5217 Overall verdict: pass
5223 .*---------------------------------------------------------------------*
5224 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (0),Short form CER,DER
5225 .*---------------------------------------------------------------------*
5228 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (0),Short form CER,DER>
5236 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
5238 myIntegerValue BERPDU ::= 0
5244 import from TempA all;
5246 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5251 if (dec_BER_PDU('420100'O) == myIntegerValue)
5254 {setverdict(pass);} else {setverdict(fail);}
5259 Overall verdict: pass
5265 .*---------------------------------------------------------------------*
5266 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (0),Long form
5267 .*---------------------------------------------------------------------*
5270 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (0),Long form>
5278 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
5280 myIntegerValue BERPDU ::= 0
5286 import from TempA all;
5288 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5293 if (dec_BER_PDU('42810100'O) == myIntegerValue)
5296 {setverdict(pass);} else {setverdict(fail);}
5301 Overall verdict: pass
5307 .*---------------------------------------------------------------------*
5308 :h3. DECODING INTEGER (127), CER+DER
5309 .*---------------------------------------------------------------------*
5312 <TC - DECODING INTEGER (127), CER+DER>
5322 myIntegerValue BERPDU ::= 127
5328 import from TempA all;
5330 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5335 if (dec_BER_PDU('02017F'O) == myIntegerValue)
5338 {setverdict(pass);} else {setverdict(fail);}
5343 Overall verdict: pass
5349 .*---------------------------------------------------------------------*
5350 :h3. DECODING INTEGER (127), (LENGTH OF LENGTH = 1)
5351 .*---------------------------------------------------------------------*
5354 <TC - DECODING INTEGER (127), (LENGTH OF LENGTH = 1)>
5364 myIntegerValue BERPDU ::= 127
5370 import from TempA all;
5372 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5377 if (dec_BER_PDU('0281017F'O) == myIntegerValue)
5380 {setverdict(pass);} else {setverdict(fail);}
5385 Overall verdict: pass
5391 .*---------------------------------------------------------------------*
5392 :h3. DECODING INTEGER (127), (LENGTH OF LENGTH = 2)
5393 .*---------------------------------------------------------------------*
5396 <TC - DECODING INTEGER (127), (LENGTH OF LENGTH = 2)>
5406 myIntegerValue BERPDU ::= 127
5412 import from TempA all;
5414 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5419 if (dec_BER_PDU('028200017F'O) == myIntegerValue)
5422 {setverdict(pass);} else {setverdict(fail);}
5427 Overall verdict: pass
5433 .*---------------------------------------------------------------------*
5434 :h3. DECODING [0] EXPLICIT INTEGER (127), DER
5435 .*---------------------------------------------------------------------*
5438 <TC - DECODING [0] EXPLICIT INTEGER (127), DER>
5446 BERPDU ::= [0] EXPLICIT INTEGER
5448 myIntegerValue BERPDU ::= 127
5454 import from TempA all;
5456 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5461 if (dec_BER_PDU('A00302017F'O) == myIntegerValue)
5464 {setverdict(pass);} else {setverdict(fail);}
5469 Overall verdict: pass
5475 .*---------------------------------------------------------------------*
5476 :h3. DECODING [0] EXPLICIT INTEGER (127), CER
5477 .*---------------------------------------------------------------------*
5480 <TC - DECODING [0] EXPLICIT INTEGER (127), CER>
5488 BERPDU ::= [0] EXPLICIT INTEGER
5490 myIntegerValue BERPDU ::= 127
5496 import from TempA all;
5498 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5503 if (dec_BER_PDU('A08002017F0000'O) == myIntegerValue)
5506 {setverdict(pass);} else {setverdict(fail);}
5511 Overall verdict: pass
5517 .*---------------------------------------------------------------------*
5518 :h3. DECODING [0] EXPLICIT INTEGER (127), Short form - long form
5519 .*---------------------------------------------------------------------*
5522 <TC - DECODING [0] EXPLICIT INTEGER (127), Short form - long form>
5530 BERPDU ::= [0] EXPLICIT INTEGER
5532 myIntegerValue BERPDU ::= 127
5538 import from TempA all;
5540 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5545 if (dec_BER_PDU('A00302017F'O) == myIntegerValue)
5548 {setverdict(pass);} else {setverdict(fail);}
5553 Overall verdict: pass
5559 .*---------------------------------------------------------------------*
5560 :h3. DECODING [0] EXPLICIT INTEGER (127), Long form - short form
5561 .*---------------------------------------------------------------------*
5564 <TC - DECODING [0] EXPLICIT INTEGER (127), Long form - short form>
5572 BERPDU ::= [0] EXPLICIT INTEGER
5574 myIntegerValue BERPDU ::= 127
5580 import from TempA all;
5582 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5587 if (dec_BER_PDU('A0810302017F'O) == myIntegerValue)
5590 {setverdict(pass);} else {setverdict(fail);}
5595 Overall verdict: pass
5601 .*---------------------------------------------------------------------*
5602 :h3. DECODING [0] EXPLICIT INTEGER (127), Long form Long form
5603 .*---------------------------------------------------------------------*
5606 <TC - DECODING [0] EXPLICIT INTEGER (127), Long form Long form>
5614 BERPDU ::= [0] EXPLICIT INTEGER
5616 myIntegerValue BERPDU ::= 127
5622 import from TempA all;
5624 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5629 if (dec_BER_PDU('A081040281017F'O) == myIntegerValue)
5632 {setverdict(pass);} else {setverdict(fail);}
5637 Overall verdict: pass
5643 .*---------------------------------------------------------------------*
5644 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Short form - Short form, DER
5645 .*---------------------------------------------------------------------*
5648 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Short form - Short form, DER>
5656 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
5658 myIntegerValue BERPDU ::= 127
5664 import from TempA all;
5666 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5671 if (dec_BER_PDU('E10302017F'O) == myIntegerValue)
5674 {setverdict(pass);} else {setverdict(fail);}
5679 Overall verdict: pass
5685 .*---------------------------------------------------------------------*
5686 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Short form - long form
5687 .*---------------------------------------------------------------------*
5690 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Short form - long form>
5698 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
5700 myIntegerValue BERPDU ::= 127
5706 import from TempA all;
5708 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5713 if (dec_BER_PDU('E1040281017F'O) == myIntegerValue)
5716 {setverdict(pass);} else {setverdict(fail);}
5721 Overall verdict: pass
5727 .*---------------------------------------------------------------------*
5728 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Long form - short form
5729 .*---------------------------------------------------------------------*
5732 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Long form - short form>
5740 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
5742 myIntegerValue BERPDU ::= 127
5748 import from TempA all;
5750 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5755 if (dec_BER_PDU('E1810302017F'O) == myIntegerValue)
5758 {setverdict(pass);} else {setverdict(fail);}
5763 Overall verdict: pass
5769 .*---------------------------------------------------------------------*
5770 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Long form Long form
5771 .*---------------------------------------------------------------------*
5774 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Long form Long form>
5782 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
5784 myIntegerValue BERPDU ::= 127
5790 import from TempA all;
5792 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5797 if (dec_BER_PDU('E181040281017F'O) == myIntegerValue)
5800 {setverdict(pass);} else {setverdict(fail);}
5805 Overall verdict: pass
5811 .*---------------------------------------------------------------------*
5812 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127),Indefinite form,CER
5813 .*---------------------------------------------------------------------*
5816 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127),Indefinite form,CER>
5824 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
5826 myIntegerValue BERPDU ::= 127
5832 import from TempA all;
5834 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5839 if (dec_BER_PDU('E18002017F0000'O) == myIntegerValue)
5842 {setverdict(pass);} else {setverdict(fail);}
5847 Overall verdict: pass
5853 .*---------------------------------------------------------------------*
5854 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Short form - Short form, DER
5855 .*---------------------------------------------------------------------*
5858 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Short form - Short form, DER>
5866 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
5868 myIntegerValue BERPDU ::= 127
5874 import from TempA all;
5876 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5881 if (dec_BER_PDU('620302017F'O) == myIntegerValue)
5884 {setverdict(pass);} else {setverdict(fail);}
5889 Overall verdict: pass
5895 .*---------------------------------------------------------------------*
5896 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Short form - long form
5897 .*---------------------------------------------------------------------*
5900 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Short form - long form>
5908 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
5910 myIntegerValue BERPDU ::= 127
5916 import from TempA all;
5918 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5923 if (dec_BER_PDU('62040281017F'O) == myIntegerValue)
5926 {setverdict(pass);} else {setverdict(fail);}
5931 Overall verdict: pass
5937 .*---------------------------------------------------------------------*
5938 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Long form - short form
5939 .*---------------------------------------------------------------------*
5942 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Long form - short form>
5950 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
5952 myIntegerValue BERPDU ::= 127
5958 import from TempA all;
5960 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
5965 if (dec_BER_PDU('62810302017F'O) == myIntegerValue)
5968 {setverdict(pass);} else {setverdict(fail);}
5973 Overall verdict: pass
5979 .*---------------------------------------------------------------------*
5980 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Long form Long form
5981 .*---------------------------------------------------------------------*
5984 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Long form Long form>
5992 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
5994 myIntegerValue BERPDU ::= 127
6000 import from TempA all;
6002 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6007 if (dec_BER_PDU('6281040281017F'O) == myIntegerValue)
6010 {setverdict(pass);} else {setverdict(fail);}
6015 Overall verdict: pass
6021 .*---------------------------------------------------------------------*
6022 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127),Indefinite form,CER
6023 .*---------------------------------------------------------------------*
6026 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127),Indefinite form,CER>
6034 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
6036 myIntegerValue BERPDU ::= 127
6042 import from TempA all;
6044 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6049 if (dec_BER_PDU('628002017F0000'O) == myIntegerValue)
6052 {setverdict(pass);} else {setverdict(fail);}
6057 Overall verdict: pass
6063 .*---------------------------------------------------------------------*
6064 :h3. DECODING [0] IMPLICIT INTEGER (127),Short form CER,DER
6065 .*---------------------------------------------------------------------*
6068 <TC - DECODING [0] IMPLICIT INTEGER (127),Short form CER,DER>
6076 BERPDU ::= [0] IMPLICIT INTEGER
6078 myIntegerValue BERPDU ::= 127
6084 import from TempA all;
6086 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6091 if (dec_BER_PDU('80017F'O) == myIntegerValue)
6094 {setverdict(pass);} else {setverdict(fail);}
6099 Overall verdict: pass
6105 .*---------------------------------------------------------------------*
6106 :h3. DECODING [0] IMPLICIT INTEGER (127),Long form
6107 .*---------------------------------------------------------------------*
6110 <TC - DECODING [0] IMPLICIT INTEGER (127),Long form>
6118 BERPDU ::= [0] IMPLICIT INTEGER
6120 myIntegerValue BERPDU ::= 127
6126 import from TempA all;
6128 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6133 if (dec_BER_PDU('8081017F'O) == myIntegerValue)
6136 {setverdict(pass);} else {setverdict(fail);}
6141 Overall verdict: pass
6147 .*---------------------------------------------------------------------*
6148 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (127),Short form CER,DER
6149 .*---------------------------------------------------------------------*
6152 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (127),Short form CER,DER>
6160 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
6162 myIntegerValue BERPDU ::= 127
6168 import from TempA all;
6170 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6175 if (dec_BER_PDU('C1017F'O) == myIntegerValue)
6178 {setverdict(pass);} else {setverdict(fail);}
6183 Overall verdict: pass
6189 .*---------------------------------------------------------------------*
6190 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (127),Long form
6191 .*---------------------------------------------------------------------*
6194 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (127),Long form>
6202 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
6204 myIntegerValue BERPDU ::= 127
6210 import from TempA all;
6212 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6217 if (dec_BER_PDU('C181017F'O) == myIntegerValue)
6220 {setverdict(pass);} else {setverdict(fail);}
6225 Overall verdict: pass
6231 .*---------------------------------------------------------------------*
6232 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (127),Short form CER,DER
6233 .*---------------------------------------------------------------------*
6236 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (127),Short form CER,DER>
6244 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
6246 myIntegerValue BERPDU ::= 127
6252 import from TempA all;
6254 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6259 if (dec_BER_PDU('42017F'O) == myIntegerValue)
6262 {setverdict(pass);} else {setverdict(fail);}
6267 Overall verdict: pass
6273 .*---------------------------------------------------------------------*
6274 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (127),Long form
6275 .*---------------------------------------------------------------------*
6278 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (127),Long form>
6286 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
6288 myIntegerValue BERPDU ::= 127
6294 import from TempA all;
6296 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6301 if (dec_BER_PDU('4281017F'O) == myIntegerValue)
6304 {setverdict(pass);} else {setverdict(fail);}
6309 Overall verdict: pass
6315 .*---------------------------------------------------------------------*
6316 :h3. DECODING INTEGER (-128), CER+DER
6317 .*---------------------------------------------------------------------*
6320 <TC - DECODING INTEGER (-128), CER+DER>
6330 myIntegerValue BERPDU ::= -128
6336 import from TempA all;
6338 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6343 if (dec_BER_PDU('020180'O) == myIntegerValue)
6346 {setverdict(pass);} else {setverdict(fail);}
6351 Overall verdict: pass
6357 .*---------------------------------------------------------------------*
6358 :h3. DECODING INTEGER (-128), (LENGTH OF LENGTH = 1)
6359 .*---------------------------------------------------------------------*
6362 <TC - DECODING INTEGER (-128), (LENGTH OF LENGTH = 1)>
6372 myIntegerValue BERPDU ::= -128
6378 import from TempA all;
6380 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6385 if (dec_BER_PDU('02810180'O) == myIntegerValue)
6388 {setverdict(pass);} else {setverdict(fail);}
6393 Overall verdict: pass
6399 .*---------------------------------------------------------------------*
6400 :h3. DECODING INTEGER (-128), (LENGTH OF LENGTH = 2)
6401 .*---------------------------------------------------------------------*
6404 <TC - DECODING INTEGER (-128), (LENGTH OF LENGTH = 2)>
6414 myIntegerValue BERPDU ::= -128
6420 import from TempA all;
6422 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6427 if (dec_BER_PDU('0282000180'O) == myIntegerValue)
6430 {setverdict(pass);} else {setverdict(fail);}
6435 Overall verdict: pass
6441 .*---------------------------------------------------------------------*
6442 :h3. DECODING [0] EXPLICIT INTEGER (-128), DER
6443 .*---------------------------------------------------------------------*
6446 <TC - DECODING [0] EXPLICIT INTEGER (-128), DER>
6454 BERPDU ::= [0] EXPLICIT INTEGER
6456 myIntegerValue BERPDU ::= -128
6462 import from TempA all;
6464 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6469 if (dec_BER_PDU('A003020180'O) == myIntegerValue)
6472 {setverdict(pass);} else {setverdict(fail);}
6477 Overall verdict: pass
6483 .*---------------------------------------------------------------------*
6484 :h3. DECODING [0] EXPLICIT INTEGER (-128), CER
6485 .*---------------------------------------------------------------------*
6488 <TC - DECODING [0] EXPLICIT INTEGER (-128), CER>
6496 BERPDU ::= [0] EXPLICIT INTEGER
6498 myIntegerValue BERPDU ::= -128
6504 import from TempA all;
6506 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6511 if (dec_BER_PDU('A0800201800000'O) == myIntegerValue)
6514 {setverdict(pass);} else {setverdict(fail);}
6519 Overall verdict: pass
6525 .*---------------------------------------------------------------------*
6526 :h3. DECODING [0] EXPLICIT INTEGER (-128), Short form - long form
6527 .*---------------------------------------------------------------------*
6530 <TC - DECODING [0] EXPLICIT INTEGER (-128), Short form - long form>
6538 BERPDU ::= [0] EXPLICIT INTEGER
6540 myIntegerValue BERPDU ::= -128
6546 import from TempA all;
6548 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6553 if (dec_BER_PDU('A003020180'O) == myIntegerValue)
6556 {setverdict(pass);} else {setverdict(fail);}
6561 Overall verdict: pass
6567 .*---------------------------------------------------------------------*
6568 :h3. DECODING [0] EXPLICIT INTEGER (-128), Long form - short form
6569 .*---------------------------------------------------------------------*
6572 <TC - DECODING [0] EXPLICIT INTEGER (-128), Long form - short form>
6580 BERPDU ::= [0] EXPLICIT INTEGER
6582 myIntegerValue BERPDU ::= -128
6588 import from TempA all;
6590 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6595 if (dec_BER_PDU('A08103020180'O) == myIntegerValue)
6598 {setverdict(pass);} else {setverdict(fail);}
6603 Overall verdict: pass
6609 .*---------------------------------------------------------------------*
6610 :h3. DECODING [0] EXPLICIT INTEGER (-128), Long form Long form
6611 .*---------------------------------------------------------------------*
6614 <TC - DECODING [0] EXPLICIT INTEGER (-128), Long form Long form>
6622 BERPDU ::= [0] EXPLICIT INTEGER
6624 myIntegerValue BERPDU ::= -128
6630 import from TempA all;
6632 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6637 if (dec_BER_PDU('A0810402810180'O) == myIntegerValue)
6640 {setverdict(pass);} else {setverdict(fail);}
6645 Overall verdict: pass
6651 .*---------------------------------------------------------------------*
6652 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Short form - Short form, DER
6653 .*---------------------------------------------------------------------*
6656 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Short form - Short form, DER>
6664 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
6666 myIntegerValue BERPDU ::= -128
6672 import from TempA all;
6674 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6679 if (dec_BER_PDU('E103020180'O) == myIntegerValue)
6682 {setverdict(pass);} else {setverdict(fail);}
6687 Overall verdict: pass
6693 .*---------------------------------------------------------------------*
6694 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Short form - long form
6695 .*---------------------------------------------------------------------*
6698 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Short form - long form>
6706 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
6708 myIntegerValue BERPDU ::= -128
6714 import from TempA all;
6716 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6721 if (dec_BER_PDU('E10402810180'O) == myIntegerValue)
6724 {setverdict(pass);} else {setverdict(fail);}
6729 Overall verdict: pass
6735 .*---------------------------------------------------------------------*
6736 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Long form - short form
6737 .*---------------------------------------------------------------------*
6740 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Long form - short form>
6748 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
6750 myIntegerValue BERPDU ::= -128
6756 import from TempA all;
6758 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6763 if (dec_BER_PDU('E18103020180'O) == myIntegerValue)
6766 {setverdict(pass);} else {setverdict(fail);}
6771 Overall verdict: pass
6777 .*---------------------------------------------------------------------*
6778 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Long form Long form
6779 .*---------------------------------------------------------------------*
6782 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Long form Long form>
6790 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
6792 myIntegerValue BERPDU ::= -128
6798 import from TempA all;
6800 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6805 if (dec_BER_PDU('E1810402810180'O) == myIntegerValue)
6808 {setverdict(pass);} else {setverdict(fail);}
6813 Overall verdict: pass
6819 .*---------------------------------------------------------------------*
6820 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128),Indefinite form,CER
6821 .*---------------------------------------------------------------------*
6824 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128),Indefinite form,CER>
6832 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
6834 myIntegerValue BERPDU ::= -128
6840 import from TempA all;
6842 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6847 if (dec_BER_PDU('E1800201800000'O) == myIntegerValue)
6850 {setverdict(pass);} else {setverdict(fail);}
6855 Overall verdict: pass
6861 .*---------------------------------------------------------------------*
6862 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Short form - Short form, DER
6863 .*---------------------------------------------------------------------*
6866 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Short form - Short form, DER>
6874 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
6876 myIntegerValue BERPDU ::= -128
6882 import from TempA all;
6884 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6889 if (dec_BER_PDU('6203020180'O) == myIntegerValue)
6892 {setverdict(pass);} else {setverdict(fail);}
6897 Overall verdict: pass
6903 .*---------------------------------------------------------------------*
6904 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Short form - long form
6905 .*---------------------------------------------------------------------*
6908 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Short form - long form>
6916 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
6918 myIntegerValue BERPDU ::= -128
6924 import from TempA all;
6926 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6931 if (dec_BER_PDU('620402810180'O) == myIntegerValue)
6934 {setverdict(pass);} else {setverdict(fail);}
6939 Overall verdict: pass
6945 .*---------------------------------------------------------------------*
6946 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Long form - short form
6947 .*---------------------------------------------------------------------*
6950 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Long form - short form>
6958 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
6960 myIntegerValue BERPDU ::= -128
6966 import from TempA all;
6968 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
6973 if (dec_BER_PDU('628103020180'O) == myIntegerValue)
6976 {setverdict(pass);} else {setverdict(fail);}
6981 Overall verdict: pass
6987 .*---------------------------------------------------------------------*
6988 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Long form Long form
6989 .*---------------------------------------------------------------------*
6992 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Long form Long form>
7000 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
7002 myIntegerValue BERPDU ::= -128
7008 import from TempA all;
7010 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7015 if (dec_BER_PDU('62810402810180'O) == myIntegerValue)
7018 {setverdict(pass);} else {setverdict(fail);}
7023 Overall verdict: pass
7029 .*---------------------------------------------------------------------*
7030 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128),Indefinite form,CER
7031 .*---------------------------------------------------------------------*
7034 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128),Indefinite form,CER>
7042 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
7044 myIntegerValue BERPDU ::= -128
7050 import from TempA all;
7052 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7057 if (dec_BER_PDU('62800201800000'O) == myIntegerValue)
7060 {setverdict(pass);} else {setverdict(fail);}
7065 Overall verdict: pass
7071 .*---------------------------------------------------------------------*
7072 :h3. DECODING [0] IMPLICIT INTEGER (-128),Short form CER,DER
7073 .*---------------------------------------------------------------------*
7076 <TC - DECODING [0] IMPLICIT INTEGER (-128),Short form CER,DER>
7084 BERPDU ::= [0] IMPLICIT INTEGER
7086 myIntegerValue BERPDU ::= -128
7092 import from TempA all;
7094 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7099 if (dec_BER_PDU('800180'O) == myIntegerValue)
7102 {setverdict(pass);} else {setverdict(fail);}
7107 Overall verdict: pass
7113 .*---------------------------------------------------------------------*
7114 :h3. DECODING [0] IMPLICIT INTEGER (-128),Long form
7115 .*---------------------------------------------------------------------*
7118 <TC - DECODING [0] IMPLICIT INTEGER (-128),Long form>
7126 BERPDU ::= [0] IMPLICIT INTEGER
7128 myIntegerValue BERPDU ::= -128
7134 import from TempA all;
7136 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7141 if (dec_BER_PDU('80810180'O) == myIntegerValue)
7144 {setverdict(pass);} else {setverdict(fail);}
7149 Overall verdict: pass
7155 .*---------------------------------------------------------------------*
7156 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-128),Short form CER,DER
7157 .*---------------------------------------------------------------------*
7160 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-128),Short form CER,DER>
7168 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
7170 myIntegerValue BERPDU ::= -128
7176 import from TempA all;
7178 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7183 if (dec_BER_PDU('C10180'O) == myIntegerValue)
7186 {setverdict(pass);} else {setverdict(fail);}
7191 Overall verdict: pass
7197 .*---------------------------------------------------------------------*
7198 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-128),Long form
7199 .*---------------------------------------------------------------------*
7202 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-128),Long form>
7210 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
7212 myIntegerValue BERPDU ::= -128
7218 import from TempA all;
7220 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7225 if (dec_BER_PDU('C1810180'O) == myIntegerValue)
7228 {setverdict(pass);} else {setverdict(fail);}
7233 Overall verdict: pass
7239 .*---------------------------------------------------------------------*
7240 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-128),Short form CER,DER
7241 .*---------------------------------------------------------------------*
7244 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-128),Short form CER,DER>
7252 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
7254 myIntegerValue BERPDU ::= -128
7260 import from TempA all;
7262 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7267 if (dec_BER_PDU('420180'O) == myIntegerValue)
7270 {setverdict(pass);} else {setverdict(fail);}
7275 Overall verdict: pass
7281 .*---------------------------------------------------------------------*
7282 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-128),Long form
7283 .*---------------------------------------------------------------------*
7286 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-128),Long form>
7294 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
7296 myIntegerValue BERPDU ::= -128
7302 import from TempA all;
7304 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7309 if (dec_BER_PDU('42810180'O) == myIntegerValue)
7312 {setverdict(pass);} else {setverdict(fail);}
7317 Overall verdict: pass
7323 .*---------------------------------------------------------------------*
7324 :h3. DECODING INTEGER (-5), CER+DER
7325 .*---------------------------------------------------------------------*
7328 <TC - DECODING INTEGER (-5), CER+DER>
7338 myIntegerValue BERPDU ::= -5
7344 import from TempA all;
7346 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7351 if (dec_BER_PDU('0201FB'O) == myIntegerValue)
7354 {setverdict(pass);} else {setverdict(fail);}
7359 Overall verdict: pass
7365 .*---------------------------------------------------------------------*
7366 :h3. DECODING INTEGER (-5), (LENGTH OF LENGTH = 1)
7367 .*---------------------------------------------------------------------*
7370 <TC - DECODING INTEGER (-5), (LENGTH OF LENGTH = 1)>
7380 myIntegerValue BERPDU ::= -5
7386 import from TempA all;
7388 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7393 if (dec_BER_PDU('028101FB'O) == myIntegerValue)
7396 {setverdict(pass);} else {setverdict(fail);}
7401 Overall verdict: pass
7407 .*---------------------------------------------------------------------*
7408 :h3. DECODING INTEGER (-5), (LENGTH OF LENGTH = 2)
7409 .*---------------------------------------------------------------------*
7412 <TC - DECODING INTEGER (-5), (LENGTH OF LENGTH = 2)>
7422 myIntegerValue BERPDU ::= -5
7428 import from TempA all;
7430 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7435 if (dec_BER_PDU('02820001FB'O) == myIntegerValue)
7438 {setverdict(pass);} else {setverdict(fail);}
7443 Overall verdict: pass
7449 .*---------------------------------------------------------------------*
7450 :h3. DECODING [0] EXPLICIT INTEGER (-5), DER
7451 .*---------------------------------------------------------------------*
7454 <TC - DECODING [0] EXPLICIT INTEGER (-5), DER>
7462 BERPDU ::= [0] EXPLICIT INTEGER
7464 myIntegerValue BERPDU ::= -5
7470 import from TempA all;
7472 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7477 if (dec_BER_PDU('A0030201FB'O) == myIntegerValue)
7480 {setverdict(pass);} else {setverdict(fail);}
7485 Overall verdict: pass
7491 .*---------------------------------------------------------------------*
7492 :h3. DECODING [0] EXPLICIT INTEGER (-5), CER
7493 .*---------------------------------------------------------------------*
7496 <TC - DECODING [0] EXPLICIT INTEGER (-5), CER>
7504 BERPDU ::= [0] EXPLICIT INTEGER
7506 myIntegerValue BERPDU ::= -5
7512 import from TempA all;
7514 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7519 if (dec_BER_PDU('A0800201FB0000'O) == myIntegerValue)
7522 {setverdict(pass);} else {setverdict(fail);}
7527 Overall verdict: pass
7533 .*---------------------------------------------------------------------*
7534 :h3. DECODING [0] EXPLICIT INTEGER (-5), Short form - long form
7535 .*---------------------------------------------------------------------*
7538 <TC - DECODING [0] EXPLICIT INTEGER (-5), Short form - long form>
7546 BERPDU ::= [0] EXPLICIT INTEGER
7548 myIntegerValue BERPDU ::= -5
7554 import from TempA all;
7556 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7561 if (dec_BER_PDU('A0030201FB'O) == myIntegerValue)
7564 {setverdict(pass);} else {setverdict(fail);}
7569 Overall verdict: pass
7575 .*---------------------------------------------------------------------*
7576 :h3. DECODING [0] EXPLICIT INTEGER (-5), Long form - short form
7577 .*---------------------------------------------------------------------*
7580 <TC - DECODING [0] EXPLICIT INTEGER (-5), Long form - short form>
7588 BERPDU ::= [0] EXPLICIT INTEGER
7590 myIntegerValue BERPDU ::= -5
7596 import from TempA all;
7598 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7603 if (dec_BER_PDU('A081030201FB'O) == myIntegerValue)
7606 {setverdict(pass);} else {setverdict(fail);}
7611 Overall verdict: pass
7617 .*---------------------------------------------------------------------*
7618 :h3. DECODING [0] EXPLICIT INTEGER (-5), Long form Long form
7619 .*---------------------------------------------------------------------*
7622 <TC - DECODING [0] EXPLICIT INTEGER (-5), Long form Long form>
7630 BERPDU ::= [0] EXPLICIT INTEGER
7632 myIntegerValue BERPDU ::= -5
7638 import from TempA all;
7640 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7645 if (dec_BER_PDU('A08104028101FB'O) == myIntegerValue)
7648 {setverdict(pass);} else {setverdict(fail);}
7653 Overall verdict: pass
7659 .*---------------------------------------------------------------------*
7660 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Short form - Short form, DER
7661 .*---------------------------------------------------------------------*
7664 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Short form - Short form, DER>
7672 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
7674 myIntegerValue BERPDU ::= -5
7680 import from TempA all;
7682 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7687 if (dec_BER_PDU('E1030201FB'O) == myIntegerValue)
7690 {setverdict(pass);} else {setverdict(fail);}
7695 Overall verdict: pass
7701 .*---------------------------------------------------------------------*
7702 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Short form - long form
7703 .*---------------------------------------------------------------------*
7706 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Short form - long form>
7714 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
7716 myIntegerValue BERPDU ::= -5
7722 import from TempA all;
7724 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7729 if (dec_BER_PDU('E104028101FB'O) == myIntegerValue)
7732 {setverdict(pass);} else {setverdict(fail);}
7737 Overall verdict: pass
7743 .*---------------------------------------------------------------------*
7744 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Long form - short form
7745 .*---------------------------------------------------------------------*
7748 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Long form - short form>
7756 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
7758 myIntegerValue BERPDU ::= -5
7764 import from TempA all;
7766 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7771 if (dec_BER_PDU('E181030201FB'O) == myIntegerValue)
7774 {setverdict(pass);} else {setverdict(fail);}
7779 Overall verdict: pass
7785 .*---------------------------------------------------------------------*
7786 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Long form Long form
7787 .*---------------------------------------------------------------------*
7790 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Long form Long form>
7798 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
7800 myIntegerValue BERPDU ::= -5
7806 import from TempA all;
7808 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7813 if (dec_BER_PDU('E18104028101FB'O) == myIntegerValue)
7816 {setverdict(pass);} else {setverdict(fail);}
7821 Overall verdict: pass
7827 .*---------------------------------------------------------------------*
7828 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5),Indefinite form,CER
7829 .*---------------------------------------------------------------------*
7832 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5),Indefinite form,CER>
7840 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
7842 myIntegerValue BERPDU ::= -5
7848 import from TempA all;
7850 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7855 if (dec_BER_PDU('E1800201FB0000'O) == myIntegerValue)
7858 {setverdict(pass);} else {setverdict(fail);}
7863 Overall verdict: pass
7869 .*---------------------------------------------------------------------*
7870 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Short form - Short form, DER
7871 .*---------------------------------------------------------------------*
7874 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Short form - Short form, DER>
7882 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
7884 myIntegerValue BERPDU ::= -5
7890 import from TempA all;
7892 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7897 if (dec_BER_PDU('62030201FB'O) == myIntegerValue)
7900 {setverdict(pass);} else {setverdict(fail);}
7905 Overall verdict: pass
7911 .*---------------------------------------------------------------------*
7912 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Short form - long form
7913 .*---------------------------------------------------------------------*
7916 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Short form - long form>
7924 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
7926 myIntegerValue BERPDU ::= -5
7932 import from TempA all;
7934 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7939 if (dec_BER_PDU('6204028101FB'O) == myIntegerValue)
7942 {setverdict(pass);} else {setverdict(fail);}
7947 Overall verdict: pass
7953 .*---------------------------------------------------------------------*
7954 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Long form - short form
7955 .*---------------------------------------------------------------------*
7958 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Long form - short form>
7966 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
7968 myIntegerValue BERPDU ::= -5
7974 import from TempA all;
7976 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
7981 if (dec_BER_PDU('6281030201FB'O) == myIntegerValue)
7984 {setverdict(pass);} else {setverdict(fail);}
7989 Overall verdict: pass
7995 .*---------------------------------------------------------------------*
7996 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Long form Long form
7997 .*---------------------------------------------------------------------*
8000 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Long form Long form>
8008 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
8010 myIntegerValue BERPDU ::= -5
8016 import from TempA all;
8018 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8023 if (dec_BER_PDU('628104028101FB'O) == myIntegerValue)
8026 {setverdict(pass);} else {setverdict(fail);}
8031 Overall verdict: pass
8037 .*---------------------------------------------------------------------*
8038 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5),Indefinite form,CER
8039 .*---------------------------------------------------------------------*
8042 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5),Indefinite form,CER>
8050 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
8052 myIntegerValue BERPDU ::= -5
8058 import from TempA all;
8060 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8065 if (dec_BER_PDU('62800201FB0000'O) == myIntegerValue)
8068 {setverdict(pass);} else {setverdict(fail);}
8073 Overall verdict: pass
8079 .*---------------------------------------------------------------------*
8080 :h3. DECODING [0] IMPLICIT INTEGER (-5),Short form CER,DER
8081 .*---------------------------------------------------------------------*
8084 <TC - DECODING [0] IMPLICIT INTEGER (-5),Short form CER,DER>
8092 BERPDU ::= [0] IMPLICIT INTEGER
8094 myIntegerValue BERPDU ::= -5
8100 import from TempA all;
8102 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8107 if (dec_BER_PDU('8001FB'O) == myIntegerValue)
8110 {setverdict(pass);} else {setverdict(fail);}
8115 Overall verdict: pass
8121 .*---------------------------------------------------------------------*
8122 :h3. DECODING [0] IMPLICIT INTEGER (-5),Long form
8123 .*---------------------------------------------------------------------*
8126 <TC - DECODING [0] IMPLICIT INTEGER (-5),Long form>
8134 BERPDU ::= [0] IMPLICIT INTEGER
8136 myIntegerValue BERPDU ::= -5
8142 import from TempA all;
8144 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8149 if (dec_BER_PDU('808101FB'O) == myIntegerValue)
8152 {setverdict(pass);} else {setverdict(fail);}
8157 Overall verdict: pass
8163 .*---------------------------------------------------------------------*
8164 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-5),Short form CER,DER
8165 .*---------------------------------------------------------------------*
8168 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-5),Short form CER,DER>
8176 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
8178 myIntegerValue BERPDU ::= -5
8184 import from TempA all;
8186 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8191 if (dec_BER_PDU('C101FB'O) == myIntegerValue)
8194 {setverdict(pass);} else {setverdict(fail);}
8199 Overall verdict: pass
8205 .*---------------------------------------------------------------------*
8206 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-5),Long form
8207 .*---------------------------------------------------------------------*
8210 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-5),Long form>
8218 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
8220 myIntegerValue BERPDU ::= -5
8226 import from TempA all;
8228 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8233 if (dec_BER_PDU('C18101FB'O) == myIntegerValue)
8236 {setverdict(pass);} else {setverdict(fail);}
8241 Overall verdict: pass
8247 .*---------------------------------------------------------------------*
8248 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-5),Short form CER,DER
8249 .*---------------------------------------------------------------------*
8252 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-5),Short form CER,DER>
8260 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
8262 myIntegerValue BERPDU ::= -5
8268 import from TempA all;
8270 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8275 if (dec_BER_PDU('4201FB'O) == myIntegerValue)
8278 {setverdict(pass);} else {setverdict(fail);}
8283 Overall verdict: pass
8289 .*---------------------------------------------------------------------*
8290 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-5),Long form
8291 .*---------------------------------------------------------------------*
8294 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-5),Long form>
8302 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
8304 myIntegerValue BERPDU ::= -5
8310 import from TempA all;
8312 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8317 if (dec_BER_PDU('428101FB'O) == myIntegerValue)
8320 {setverdict(pass);} else {setverdict(fail);}
8325 Overall verdict: pass
8331 .*---------------------------------------------------------------------*
8332 :h3. DECODING INTEGER (128), CER+DER
8333 .*---------------------------------------------------------------------*
8336 <TC - DECODING INTEGER (128), CER+DER>
8346 myIntegerValue BERPDU ::= 128
8352 import from TempA all;
8354 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8359 if (dec_BER_PDU('02020080'O) == myIntegerValue)
8362 {setverdict(pass);} else {setverdict(fail);}
8367 Overall verdict: pass
8373 .*---------------------------------------------------------------------*
8374 :h3. DECODING INTEGER (128), (LENGTH OF LENGTH = 1)
8375 .*---------------------------------------------------------------------*
8378 <TC - DECODING INTEGER (128), (LENGTH OF LENGTH = 1)>
8388 myIntegerValue BERPDU ::= 128
8394 import from TempA all;
8396 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8401 if (dec_BER_PDU('0281020080'O) == myIntegerValue)
8404 {setverdict(pass);} else {setverdict(fail);}
8409 Overall verdict: pass
8415 .*---------------------------------------------------------------------*
8416 :h3. DECODING INTEGER (128), (LENGTH OF LENGTH = 2)
8417 .*---------------------------------------------------------------------*
8420 <TC - DECODING INTEGER (128), (LENGTH OF LENGTH = 2)>
8430 myIntegerValue BERPDU ::= 128
8436 import from TempA all;
8438 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8443 if (dec_BER_PDU('028200020080'O) == myIntegerValue)
8446 {setverdict(pass);} else {setverdict(fail);}
8451 Overall verdict: pass
8457 .*---------------------------------------------------------------------*
8458 :h3. DECODING [0] EXPLICIT INTEGER (128), DER
8459 .*---------------------------------------------------------------------*
8462 <TC - DECODING [0] EXPLICIT INTEGER (128), DER>
8470 BERPDU ::= [0] EXPLICIT INTEGER
8472 myIntegerValue BERPDU ::= 128
8478 import from TempA all;
8480 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8485 if (dec_BER_PDU('A00402020080'O) == myIntegerValue)
8488 {setverdict(pass);} else {setverdict(fail);}
8493 Overall verdict: pass
8499 .*---------------------------------------------------------------------*
8500 :h3. DECODING [0] EXPLICIT INTEGER (128), CER
8501 .*---------------------------------------------------------------------*
8504 <TC - DECODING [0] EXPLICIT INTEGER (128), CER>
8512 BERPDU ::= [0] EXPLICIT INTEGER
8514 myIntegerValue BERPDU ::= 128
8520 import from TempA all;
8522 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8527 if (dec_BER_PDU('A080020200800000'O) == myIntegerValue)
8530 {setverdict(pass);} else {setverdict(fail);}
8535 Overall verdict: pass
8541 .*---------------------------------------------------------------------*
8542 :h3. DECODING [0] EXPLICIT INTEGER (128), Short form - long form
8543 .*---------------------------------------------------------------------*
8546 <TC - DECODING [0] EXPLICIT INTEGER (128), Short form - long form>
8554 BERPDU ::= [0] EXPLICIT INTEGER
8556 myIntegerValue BERPDU ::= 128
8562 import from TempA all;
8564 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8569 if (dec_BER_PDU('A00402020080'O) == myIntegerValue)
8572 {setverdict(pass);} else {setverdict(fail);}
8577 Overall verdict: pass
8583 .*---------------------------------------------------------------------*
8584 :h3. DECODING [0] EXPLICIT INTEGER (128), Long form - short form
8585 .*---------------------------------------------------------------------*
8588 <TC - DECODING [0] EXPLICIT INTEGER (128), Long form - short form>
8596 BERPDU ::= [0] EXPLICIT INTEGER
8598 myIntegerValue BERPDU ::= 128
8604 import from TempA all;
8606 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8611 if (dec_BER_PDU('A0810402020080'O) == myIntegerValue)
8614 {setverdict(pass);} else {setverdict(fail);}
8619 Overall verdict: pass
8625 .*---------------------------------------------------------------------*
8626 :h3. DECODING [0] EXPLICIT INTEGER (128), Long form Long form
8627 .*---------------------------------------------------------------------*
8630 <TC - DECODING [0] EXPLICIT INTEGER (128), Long form Long form>
8638 BERPDU ::= [0] EXPLICIT INTEGER
8640 myIntegerValue BERPDU ::= 128
8646 import from TempA all;
8648 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8653 if (dec_BER_PDU('A081050281020080'O) == myIntegerValue)
8656 {setverdict(pass);} else {setverdict(fail);}
8661 Overall verdict: pass
8667 .*---------------------------------------------------------------------*
8668 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Short form - Short form, DER
8669 .*---------------------------------------------------------------------*
8672 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Short form - Short form, DER>
8680 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
8682 myIntegerValue BERPDU ::= 128
8688 import from TempA all;
8690 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8695 if (dec_BER_PDU('E10402020080'O) == myIntegerValue)
8698 {setverdict(pass);} else {setverdict(fail);}
8703 Overall verdict: pass
8709 .*---------------------------------------------------------------------*
8710 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Short form - long form
8711 .*---------------------------------------------------------------------*
8714 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Short form - long form>
8722 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
8724 myIntegerValue BERPDU ::= 128
8730 import from TempA all;
8732 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8737 if (dec_BER_PDU('E1050281020080'O) == myIntegerValue)
8740 {setverdict(pass);} else {setverdict(fail);}
8745 Overall verdict: pass
8751 .*---------------------------------------------------------------------*
8752 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Long form - short form
8753 .*---------------------------------------------------------------------*
8756 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Long form - short form>
8764 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
8766 myIntegerValue BERPDU ::= 128
8772 import from TempA all;
8774 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8779 if (dec_BER_PDU('E1810402020080'O) == myIntegerValue)
8782 {setverdict(pass);} else {setverdict(fail);}
8787 Overall verdict: pass
8793 .*---------------------------------------------------------------------*
8794 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Long form Long form
8795 .*---------------------------------------------------------------------*
8798 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Long form Long form>
8806 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
8808 myIntegerValue BERPDU ::= 128
8814 import from TempA all;
8816 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8821 if (dec_BER_PDU('E181050281020080'O) == myIntegerValue)
8824 {setverdict(pass);} else {setverdict(fail);}
8829 Overall verdict: pass
8835 .*---------------------------------------------------------------------*
8836 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128),Indefinite form,CER
8837 .*---------------------------------------------------------------------*
8840 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128),Indefinite form,CER>
8848 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
8850 myIntegerValue BERPDU ::= 128
8856 import from TempA all;
8858 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8863 if (dec_BER_PDU('E180020200800000'O) == myIntegerValue)
8866 {setverdict(pass);} else {setverdict(fail);}
8871 Overall verdict: pass
8877 .*---------------------------------------------------------------------*
8878 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Short form - Short form, DER
8879 .*---------------------------------------------------------------------*
8882 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Short form - Short form, DER>
8890 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
8892 myIntegerValue BERPDU ::= 128
8898 import from TempA all;
8900 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8905 if (dec_BER_PDU('620402020080'O) == myIntegerValue)
8908 {setverdict(pass);} else {setverdict(fail);}
8913 Overall verdict: pass
8919 .*---------------------------------------------------------------------*
8920 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Short form - long form
8921 .*---------------------------------------------------------------------*
8924 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Short form - long form>
8932 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
8934 myIntegerValue BERPDU ::= 128
8940 import from TempA all;
8942 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8947 if (dec_BER_PDU('62050281020080'O) == myIntegerValue)
8950 {setverdict(pass);} else {setverdict(fail);}
8955 Overall verdict: pass
8961 .*---------------------------------------------------------------------*
8962 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Long form - short form
8963 .*---------------------------------------------------------------------*
8966 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Long form - short form>
8974 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
8976 myIntegerValue BERPDU ::= 128
8982 import from TempA all;
8984 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
8989 if (dec_BER_PDU('62810402020080'O) == myIntegerValue)
8992 {setverdict(pass);} else {setverdict(fail);}
8997 Overall verdict: pass
9003 .*---------------------------------------------------------------------*
9004 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Long form Long form
9005 .*---------------------------------------------------------------------*
9008 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Long form Long form>
9016 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
9018 myIntegerValue BERPDU ::= 128
9024 import from TempA all;
9026 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9031 if (dec_BER_PDU('6281050281020080'O) == myIntegerValue)
9034 {setverdict(pass);} else {setverdict(fail);}
9039 Overall verdict: pass
9045 .*---------------------------------------------------------------------*
9046 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128),Indefinite form,CER
9047 .*---------------------------------------------------------------------*
9050 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128),Indefinite form,CER>
9058 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
9060 myIntegerValue BERPDU ::= 128
9066 import from TempA all;
9068 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9073 if (dec_BER_PDU('6280020200800000'O) == myIntegerValue)
9076 {setverdict(pass);} else {setverdict(fail);}
9081 Overall verdict: pass
9087 .*---------------------------------------------------------------------*
9088 :h3. DECODING [0] IMPLICIT INTEGER (128),Short form CER,DER
9089 .*---------------------------------------------------------------------*
9092 <TC - DECODING [0] IMPLICIT INTEGER (128),Short form CER,DER>
9100 BERPDU ::= [0] IMPLICIT INTEGER
9102 myIntegerValue BERPDU ::= 128
9108 import from TempA all;
9110 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9115 if (dec_BER_PDU('80020080'O) == myIntegerValue)
9118 {setverdict(pass);} else {setverdict(fail);}
9123 Overall verdict: pass
9129 .*---------------------------------------------------------------------*
9130 :h3. DECODING [0] IMPLICIT INTEGER (128),Long form
9131 .*---------------------------------------------------------------------*
9134 <TC - DECODING [0] IMPLICIT INTEGER (128),Long form>
9142 BERPDU ::= [0] IMPLICIT INTEGER
9144 myIntegerValue BERPDU ::= 128
9150 import from TempA all;
9152 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9157 if (dec_BER_PDU('8081020080'O) == myIntegerValue)
9160 {setverdict(pass);} else {setverdict(fail);}
9165 Overall verdict: pass
9171 .*---------------------------------------------------------------------*
9172 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (128),Short form CER,DER
9173 .*---------------------------------------------------------------------*
9176 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (128),Short form CER,DER>
9184 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
9186 myIntegerValue BERPDU ::= 128
9192 import from TempA all;
9194 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9199 if (dec_BER_PDU('C1020080'O) == myIntegerValue)
9202 {setverdict(pass);} else {setverdict(fail);}
9207 Overall verdict: pass
9213 .*---------------------------------------------------------------------*
9214 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (128),Long form
9215 .*---------------------------------------------------------------------*
9218 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (128),Long form>
9226 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
9228 myIntegerValue BERPDU ::= 128
9234 import from TempA all;
9236 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9241 if (dec_BER_PDU('C181020080'O) == myIntegerValue)
9244 {setverdict(pass);} else {setverdict(fail);}
9249 Overall verdict: pass
9255 .*---------------------------------------------------------------------*
9256 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (128),Short form CER,DER
9257 .*---------------------------------------------------------------------*
9260 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (128),Short form CER,DER>
9268 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
9270 myIntegerValue BERPDU ::= 128
9276 import from TempA all;
9278 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9283 if (dec_BER_PDU('42020080'O) == myIntegerValue)
9286 {setverdict(pass);} else {setverdict(fail);}
9291 Overall verdict: pass
9297 .*---------------------------------------------------------------------*
9298 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (128),Long form
9299 .*---------------------------------------------------------------------*
9302 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (128),Long form>
9310 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
9312 myIntegerValue BERPDU ::= 128
9318 import from TempA all;
9320 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9325 if (dec_BER_PDU('4281020080'O) == myIntegerValue)
9328 {setverdict(pass);} else {setverdict(fail);}
9333 Overall verdict: pass
9339 .*---------------------------------------------------------------------*
9340 :h3. DECODING INTEGER (-129), CER+DER
9341 .*---------------------------------------------------------------------*
9344 <TC - DECODING INTEGER (-129), CER+DER>
9354 myIntegerValue BERPDU ::= -129
9360 import from TempA all;
9362 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9367 if (dec_BER_PDU('0202FF7F'O) == myIntegerValue)
9370 {setverdict(pass);} else {setverdict(fail);}
9375 Overall verdict: pass
9381 .*---------------------------------------------------------------------*
9382 :h3. DECODING INTEGER (-129), (LENGTH OF LENGTH = 1)
9383 .*---------------------------------------------------------------------*
9386 <TC - DECODING INTEGER (-129), (LENGTH OF LENGTH = 1)>
9396 myIntegerValue BERPDU ::= -129
9402 import from TempA all;
9404 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9409 if (dec_BER_PDU('028102FF7F'O) == myIntegerValue)
9412 {setverdict(pass);} else {setverdict(fail);}
9417 Overall verdict: pass
9423 .*---------------------------------------------------------------------*
9424 :h3. DECODING INTEGER (-129), (LENGTH OF LENGTH = 2)
9425 .*---------------------------------------------------------------------*
9428 <TC - DECODING INTEGER (-129), (LENGTH OF LENGTH = 2)>
9438 myIntegerValue BERPDU ::= -129
9444 import from TempA all;
9446 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9451 if (dec_BER_PDU('02820002FF7F'O) == myIntegerValue)
9454 {setverdict(pass);} else {setverdict(fail);}
9459 Overall verdict: pass
9465 .*---------------------------------------------------------------------*
9466 :h3. DECODING [0] EXPLICIT INTEGER (-129), DER
9467 .*---------------------------------------------------------------------*
9470 <TC - DECODING [0] EXPLICIT INTEGER (-129), DER>
9478 BERPDU ::= [0] EXPLICIT INTEGER
9480 myIntegerValue BERPDU ::= -129
9486 import from TempA all;
9488 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9493 if (dec_BER_PDU('A0040202FF7F'O) == myIntegerValue)
9496 {setverdict(pass);} else {setverdict(fail);}
9501 Overall verdict: pass
9507 .*---------------------------------------------------------------------*
9508 :h3. DECODING [0] EXPLICIT INTEGER (-129), CER
9509 .*---------------------------------------------------------------------*
9512 <TC - DECODING [0] EXPLICIT INTEGER (-129), CER>
9520 BERPDU ::= [0] EXPLICIT INTEGER
9522 myIntegerValue BERPDU ::= -129
9528 import from TempA all;
9530 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9535 if (dec_BER_PDU('A0800202FF7F0000'O) == myIntegerValue)
9538 {setverdict(pass);} else {setverdict(fail);}
9543 Overall verdict: pass
9549 .*---------------------------------------------------------------------*
9550 :h3. DECODING [0] EXPLICIT INTEGER (-129), Short form - long form
9551 .*---------------------------------------------------------------------*
9554 <TC - DECODING [0] EXPLICIT INTEGER (-129), Short form - long form>
9562 BERPDU ::= [0] EXPLICIT INTEGER
9564 myIntegerValue BERPDU ::= -129
9570 import from TempA all;
9572 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9577 if (dec_BER_PDU('A0040202FF7F'O) == myIntegerValue)
9580 {setverdict(pass);} else {setverdict(fail);}
9585 Overall verdict: pass
9591 .*---------------------------------------------------------------------*
9592 :h3. DECODING [0] EXPLICIT INTEGER (-129), Long form - short form
9593 .*---------------------------------------------------------------------*
9596 <TC - DECODING [0] EXPLICIT INTEGER (-129), Long form - short form>
9604 BERPDU ::= [0] EXPLICIT INTEGER
9606 myIntegerValue BERPDU ::= -129
9612 import from TempA all;
9614 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9619 if (dec_BER_PDU('A081040202FF7F'O) == myIntegerValue)
9622 {setverdict(pass);} else {setverdict(fail);}
9627 Overall verdict: pass
9633 .*---------------------------------------------------------------------*
9634 :h3. DECODING [0] EXPLICIT INTEGER (-129), Long form Long form
9635 .*---------------------------------------------------------------------*
9638 <TC - DECODING [0] EXPLICIT INTEGER (-129), Long form Long form>
9646 BERPDU ::= [0] EXPLICIT INTEGER
9648 myIntegerValue BERPDU ::= -129
9654 import from TempA all;
9656 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9661 if (dec_BER_PDU('A08105028102FF7F'O) == myIntegerValue)
9664 {setverdict(pass);} else {setverdict(fail);}
9669 Overall verdict: pass
9675 .*---------------------------------------------------------------------*
9676 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Short form - Short form, DER
9677 .*---------------------------------------------------------------------*
9680 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Short form - Short form, DER>
9688 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
9690 myIntegerValue BERPDU ::= -129
9696 import from TempA all;
9698 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9703 if (dec_BER_PDU('E1040202FF7F'O) == myIntegerValue)
9706 {setverdict(pass);} else {setverdict(fail);}
9711 Overall verdict: pass
9717 .*---------------------------------------------------------------------*
9718 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Short form - long form
9719 .*---------------------------------------------------------------------*
9722 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Short form - long form>
9730 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
9732 myIntegerValue BERPDU ::= -129
9738 import from TempA all;
9740 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9745 if (dec_BER_PDU('E105028102FF7F'O) == myIntegerValue)
9748 {setverdict(pass);} else {setverdict(fail);}
9753 Overall verdict: pass
9759 .*---------------------------------------------------------------------*
9760 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Long form - short form
9761 .*---------------------------------------------------------------------*
9764 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Long form - short form>
9772 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
9774 myIntegerValue BERPDU ::= -129
9780 import from TempA all;
9782 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9787 if (dec_BER_PDU('E181040202FF7F'O) == myIntegerValue)
9790 {setverdict(pass);} else {setverdict(fail);}
9795 Overall verdict: pass
9801 .*---------------------------------------------------------------------*
9802 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Long form Long form
9803 .*---------------------------------------------------------------------*
9806 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Long form Long form>
9814 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
9816 myIntegerValue BERPDU ::= -129
9822 import from TempA all;
9824 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9829 if (dec_BER_PDU('E18105028102FF7F'O) == myIntegerValue)
9832 {setverdict(pass);} else {setverdict(fail);}
9837 Overall verdict: pass
9843 .*---------------------------------------------------------------------*
9844 :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129),Indefinite form,CER
9845 .*---------------------------------------------------------------------*
9848 <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129),Indefinite form,CER>
9856 BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER
9858 myIntegerValue BERPDU ::= -129
9864 import from TempA all;
9866 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9871 if (dec_BER_PDU('E1800202FF7F0000'O) == myIntegerValue)
9874 {setverdict(pass);} else {setverdict(fail);}
9879 Overall verdict: pass
9885 .*---------------------------------------------------------------------*
9886 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Short form - Short form, DER
9887 .*---------------------------------------------------------------------*
9890 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Short form - Short form, DER>
9898 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
9900 myIntegerValue BERPDU ::= -129
9906 import from TempA all;
9908 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9913 if (dec_BER_PDU('62040202FF7F'O) == myIntegerValue)
9916 {setverdict(pass);} else {setverdict(fail);}
9921 Overall verdict: pass
9927 .*---------------------------------------------------------------------*
9928 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Short form - long form
9929 .*---------------------------------------------------------------------*
9932 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Short form - long form>
9940 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
9942 myIntegerValue BERPDU ::= -129
9948 import from TempA all;
9950 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9955 if (dec_BER_PDU('6205028102FF7F'O) == myIntegerValue)
9958 {setverdict(pass);} else {setverdict(fail);}
9963 Overall verdict: pass
9969 .*---------------------------------------------------------------------*
9970 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Long form - short form
9971 .*---------------------------------------------------------------------*
9974 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Long form - short form>
9982 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
9984 myIntegerValue BERPDU ::= -129
9990 import from TempA all;
9992 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
9997 if (dec_BER_PDU('6281040202FF7F'O) == myIntegerValue)
10000 {setverdict(pass);} else {setverdict(fail);}
10005 Overall verdict: pass
10011 .*---------------------------------------------------------------------*
10012 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Long form Long form
10013 .*---------------------------------------------------------------------*
10016 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Long form Long form>
10024 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
10026 myIntegerValue BERPDU ::= -129
10032 import from TempA all;
10034 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10039 if (dec_BER_PDU('628105028102FF7F'O) == myIntegerValue)
10042 {setverdict(pass);} else {setverdict(fail);}
10047 Overall verdict: pass
10053 .*---------------------------------------------------------------------*
10054 :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129),Indefinite form,CER
10055 .*---------------------------------------------------------------------*
10058 <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129),Indefinite form,CER>
10066 BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER
10068 myIntegerValue BERPDU ::= -129
10074 import from TempA all;
10076 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10081 if (dec_BER_PDU('62800202FF7F0000'O) == myIntegerValue)
10084 {setverdict(pass);} else {setverdict(fail);}
10089 Overall verdict: pass
10095 .*---------------------------------------------------------------------*
10096 :h3. DECODING [0] IMPLICIT INTEGER (-129),Short form CER,DER
10097 .*---------------------------------------------------------------------*
10100 <TC - DECODING [0] IMPLICIT INTEGER (-129),Short form CER,DER>
10108 BERPDU ::= [0] IMPLICIT INTEGER
10110 myIntegerValue BERPDU ::= -129
10116 import from TempA all;
10118 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10123 if (dec_BER_PDU('8002FF7F'O) == myIntegerValue)
10126 {setverdict(pass);} else {setverdict(fail);}
10131 Overall verdict: pass
10137 .*---------------------------------------------------------------------*
10138 :h3. DECODING [0] IMPLICIT INTEGER (-129),Long form
10139 .*---------------------------------------------------------------------*
10142 <TC - DECODING [0] IMPLICIT INTEGER (-129),Long form>
10150 BERPDU ::= [0] IMPLICIT INTEGER
10152 myIntegerValue BERPDU ::= -129
10158 import from TempA all;
10160 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10165 if (dec_BER_PDU('808102FF7F'O) == myIntegerValue)
10168 {setverdict(pass);} else {setverdict(fail);}
10173 Overall verdict: pass
10179 .*---------------------------------------------------------------------*
10180 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-129),Short form CER,DER
10181 .*---------------------------------------------------------------------*
10184 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-129),Short form CER,DER>
10192 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
10194 myIntegerValue BERPDU ::= -129
10200 import from TempA all;
10202 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10207 if (dec_BER_PDU('C102FF7F'O) == myIntegerValue)
10210 {setverdict(pass);} else {setverdict(fail);}
10215 Overall verdict: pass
10221 .*---------------------------------------------------------------------*
10222 :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-129),Long form
10223 .*---------------------------------------------------------------------*
10226 <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-129),Long form>
10234 BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER
10236 myIntegerValue BERPDU ::= -129
10242 import from TempA all;
10244 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10249 if (dec_BER_PDU('C18102FF7F'O) == myIntegerValue)
10252 {setverdict(pass);} else {setverdict(fail);}
10257 Overall verdict: pass
10263 .*---------------------------------------------------------------------*
10264 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-129),Short form CER,DER
10265 .*---------------------------------------------------------------------*
10268 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-129),Short form CER,DER>
10276 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
10278 myIntegerValue BERPDU ::= -129
10284 import from TempA all;
10286 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10291 if (dec_BER_PDU('4202FF7F'O) == myIntegerValue)
10294 {setverdict(pass);} else {setverdict(fail);}
10299 Overall verdict: pass
10305 .*---------------------------------------------------------------------*
10306 :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-129),Long form
10307 .*---------------------------------------------------------------------*
10310 <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-129),Long form>
10318 BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER
10320 myIntegerValue BERPDU ::= -129
10326 import from TempA all;
10328 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10333 if (dec_BER_PDU('428102FF7F'O) == myIntegerValue)
10336 {setverdict(pass);} else {setverdict(fail);}
10341 Overall verdict: pass
10347 .*---------------------------------------------------------------------*
10348 :h3. DECODING DER integer (5) with Context Specific TAG = 30
10349 .*---------------------------------------------------------------------*
10352 <TC - DECODING DER integer (5) with Context Specific TAG = 30>
10360 BERPDU ::= [30] EXPLICIT INTEGER
10362 myIntegerValue BERPDU ::= 5
10368 import from TempA all;
10370 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10375 if (dec_BER_PDU('BE03020105'O) == myIntegerValue)
10378 {setverdict(pass);} else {setverdict(fail);}
10383 Overall verdict: pass
10389 .*---------------------------------------------------------------------*
10390 :h3. DECODING CER integer (5) with Context Specific TAG = 30
10391 .*---------------------------------------------------------------------*
10394 <TC - DECODING CER integer (5) with Context Specific TAG = 30>
10402 BERPDU ::= [30] EXPLICIT INTEGER
10404 myIntegerValue BERPDU ::= 5
10410 import from TempA all;
10412 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10417 if (dec_BER_PDU('BE800201050000'O) == myIntegerValue)
10420 {setverdict(pass);} else {setverdict(fail);}
10425 Overall verdict: pass
10431 .*---------------------------------------------------------------------*
10432 :h3. DECODING DER integer (5) with Context Specific TAG = 31
10433 .*---------------------------------------------------------------------*
10436 <TC - DECODING DER integer (5) with Context Specific TAG = 31>
10444 BERPDU ::= [31] EXPLICIT INTEGER
10446 myIntegerValue BERPDU ::= 5
10452 import from TempA all;
10454 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10459 if (dec_BER_PDU('BF1F03020105'O) == myIntegerValue)
10462 {setverdict(pass);} else {setverdict(fail);}
10467 Overall verdict: pass
10473 .*---------------------------------------------------------------------*
10474 :h3. DECODING CER integer (5) with Context Specific TAG = 31
10475 .*---------------------------------------------------------------------*
10478 <TC - DECODING CER integer (5) with Context Specific TAG = 31>
10486 BERPDU ::= [31] EXPLICIT INTEGER
10488 myIntegerValue BERPDU ::= 5
10494 import from TempA all;
10496 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10501 if (dec_BER_PDU('BF1F800201050000'O) == myIntegerValue)
10504 {setverdict(pass);} else {setverdict(fail);}
10509 Overall verdict: pass
10515 .*---------------------------------------------------------------------*
10516 :h3. DECODING DER integer (5) with Context Specific TAG = 127
10517 .*---------------------------------------------------------------------*
10520 <TC - DECODING DER integer (5) with Context Specific TAG = 127>
10528 BERPDU ::= [127] EXPLICIT INTEGER
10530 myIntegerValue BERPDU ::= 5
10536 import from TempA all;
10538 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10543 if (dec_BER_PDU('BF7F03020105'O) == myIntegerValue)
10546 {setverdict(pass);} else {setverdict(fail);}
10551 Overall verdict: pass
10557 .*---------------------------------------------------------------------*
10558 :h3. DECODING CER integer (5) with Context Specific TAG = 127
10559 .*---------------------------------------------------------------------*
10562 <TC - DECODING CER integer (5) with Context Specific TAG = 127>
10570 BERPDU ::= [127] EXPLICIT INTEGER
10572 myIntegerValue BERPDU ::= 5
10578 import from TempA all;
10580 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10585 if (dec_BER_PDU('BF7F800201050000'O) == myIntegerValue)
10588 {setverdict(pass);} else {setverdict(fail);}
10593 Overall verdict: pass
10599 .*---------------------------------------------------------------------*
10600 :h3. DECODING DER integer (5) with Context Specific TAG = 128
10601 .*---------------------------------------------------------------------*
10604 <TC - DECODING DER integer (5) with Context Specific TAG = 128>
10612 BERPDU ::= [128] EXPLICIT INTEGER
10614 myIntegerValue BERPDU ::= 5
10620 import from TempA all;
10622 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10627 if (dec_BER_PDU('BF810003020105'O) == myIntegerValue)
10630 {setverdict(pass);} else {setverdict(fail);}
10635 Overall verdict: pass
10641 .*---------------------------------------------------------------------*
10642 :h3. DECODING CER integer (5) with Context Specific TAG = 128
10643 .*---------------------------------------------------------------------*
10646 <TC - DECODING CER integer (5) with Context Specific TAG = 128>
10654 BERPDU ::= [128] EXPLICIT INTEGER
10656 myIntegerValue BERPDU ::= 5
10662 import from TempA all;
10664 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10669 if (dec_BER_PDU('BF8100800201050000'O) == myIntegerValue)
10672 {setverdict(pass);} else {setverdict(fail);}
10677 Overall verdict: pass
10683 .*---------------------------------------------------------------------*
10684 :h3. DECODING DER integer (5) with Context Specific TAG = 16383
10685 .*---------------------------------------------------------------------*
10688 <TC - DECODING DER integer (5) with Context Specific TAG = 16383>
10696 BERPDU ::= [16383] EXPLICIT INTEGER
10698 myIntegerValue BERPDU ::= 5
10704 import from TempA all;
10706 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10711 if (dec_BER_PDU('BFFF7F03020105'O) == myIntegerValue)
10714 {setverdict(pass);} else {setverdict(fail);}
10719 Overall verdict: pass
10725 .*---------------------------------------------------------------------*
10726 :h3. DECODING CER integer (5) with Context Specific TAG = 16383
10727 .*---------------------------------------------------------------------*
10730 <TC - DECODING CER integer (5) with Context Specific TAG = 16383>
10738 BERPDU ::= [16383] EXPLICIT INTEGER
10740 myIntegerValue BERPDU ::= 5
10746 import from TempA all;
10748 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10753 if (dec_BER_PDU('BFFF7F800201050000'O) == myIntegerValue)
10756 {setverdict(pass);} else {setverdict(fail);}
10761 Overall verdict: pass
10767 .*---------------------------------------------------------------------*
10768 :h3. DECODING DER integer (5) with Context Specific TAG = 16384
10769 .*---------------------------------------------------------------------*
10772 <TC - DECODING DER integer (5) with Context Specific TAG = 16384>
10780 BERPDU ::= [16384] EXPLICIT INTEGER
10782 myIntegerValue BERPDU ::= 5
10788 import from TempA all;
10790 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10795 if (dec_BER_PDU('BF81800003020105'O) == myIntegerValue)
10798 {setverdict(pass);} else {setverdict(fail);}
10803 Overall verdict: pass
10809 .*---------------------------------------------------------------------*
10810 :h3. DECODING CER integer (5) with Context Specific TAG = 16384
10811 .*---------------------------------------------------------------------*
10814 <TC - DECODING CER integer (5) with Context Specific TAG = 16384>
10822 BERPDU ::= [16384] EXPLICIT INTEGER
10824 myIntegerValue BERPDU ::= 5
10830 import from TempA all;
10832 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
10837 if (dec_BER_PDU('BF818000800201050000'O) == myIntegerValue)
10840 {setverdict(pass);} else {setverdict(fail);}
10845 Overall verdict: pass
10851 .*---------------------------------------------------------------------*
10852 :h3. DER + CER encoding of ENUMERATED third(-9) hardcoded positive
10853 .*---------------------------------------------------------------------*
10856 <TC - DER + CER encoding of ENUMERATED third(-9) hardcoded positive >
10864 BERPDU ::= ENUMERATED {first(-5), second(0), third(9)}
10869 import from TempA all;
10870 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
10871 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
10873 const BERPDU b := third
10877 if ((enc_DER_PDU(b) == '0A0109'O)and(enc_CER_PDU(b) == '0A0109'O)) {setverdict(pass);} else {setverdict(fail);}
10881 Overall verdict: pass
10887 .*---------------------------------------------------------------------*
10888 :h3. DER + CER encoding of ENUMERATED first(0) hardcoded negative
10889 .*---------------------------------------------------------------------*
10892 <TC - DER + CER encoding of ENUMERATED first(0) hardcoded negative>
10900 BERPDU ::= ENUMERATED {first(-5), second(0), third(9)}
10905 import from TempA all;
10906 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
10907 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
10909 const BERPDU b := first
10913 if ((enc_DER_PDU(b) == '0A01FB'O)and(enc_CER_PDU(b) == '0A01FB'O)) {setverdict(pass);} else {setverdict(fail);}
10917 Overall verdict: pass
10923 .*---------------------------------------------------------------------*
10924 :h3. DER + CER encoding of ENUMERATED second(0) hardcoded zero
10925 .*---------------------------------------------------------------------*
10928 <TC - DER + CER encoding of ENUMERATED second(0) hardcoded zero>
10936 BERPDU ::= ENUMERATED {first(-5), second(0), third(9)}
10941 import from TempA all;
10942 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
10943 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
10945 const BERPDU b := second
10949 if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);}
10953 Overall verdict: pass
10959 .*---------------------------------------------------------------------*
10960 :h3. DER + CER encoding of ENUMERATED third, no hardcoding
10961 .*---------------------------------------------------------------------*
10964 <TC - DER + CER encoding of ENUMERATED third, no hardcoding>
10972 BERPDU ::= ENUMERATED {first, second, third}
10977 import from TempA all;
10978 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
10979 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
10981 const BERPDU b := third
10985 if ((enc_DER_PDU(b) == '0A0102'O)and(enc_CER_PDU(b) == '0A0102'O)) {setverdict(pass);} else {setverdict(fail);}
10989 Overall verdict: pass
10995 .*---------------------------------------------------------------------*
10996 :h3. DER + CER encoding of ENUMERATED first, no hardcoding
10997 .*---------------------------------------------------------------------*
11000 <TC - DER + CER encoding of ENUMERATED first, no hardcoding>
11008 BERPDU ::= ENUMERATED {first, second, third}
11013 import from TempA all;
11014 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11015 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11017 const BERPDU b := first
11021 if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);}
11025 Overall verdict: pass
11031 .*---------------------------------------------------------------------*
11032 :h3. DER + CER encoding of ENUMERATED second, no hardcoding
11033 .*---------------------------------------------------------------------*
11036 <TC - DER + CER encoding of ENUMERATED second, no hardcoding>
11044 BERPDU ::= ENUMERATED {first(-5), second(0), third(9)}
11049 import from TempA all;
11050 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11051 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11053 const BERPDU b := second
11057 if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);}
11061 Overall verdict: pass
11067 .*---------------------------------------------------------------------*
11068 :h3. DER + CER encoding of ENUMERATED first
11069 .*---------------------------------------------------------------------*
11072 <TC - DER + CER encoding of ENUMERATED first>
11080 BERPDU ::= ENUMERATED {first, second(0),third}
11085 import from TempA all;
11086 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11087 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11089 const BERPDU b := first
11093 if ((enc_DER_PDU(b) == '0A0101'O)and(enc_CER_PDU(b) == '0A0101'O)) {setverdict(pass);} else {setverdict(fail);}
11097 Overall verdict: pass
11103 .*---------------------------------------------------------------------*
11104 :h3. DER + CER encoding of ENUMERATED second(0)
11105 .*---------------------------------------------------------------------*
11108 <TC - DER + CER encoding of ENUMERATED second(0)>
11116 BERPDU ::= ENUMERATED {first, second(0),third}
11121 import from TempA all;
11122 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11123 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11125 const BERPDU b := second
11129 if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);}
11133 Overall verdict: pass
11139 .*---------------------------------------------------------------------*
11140 :h3. DER + CER encoding of ENUMERATED third
11141 .*---------------------------------------------------------------------*
11144 <TC - DER + CER encoding of ENUMERATED third>
11152 BERPDU ::= ENUMERATED {first, second(0),third}
11157 import from TempA all;
11158 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11159 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11161 const BERPDU b := third
11165 if ((enc_DER_PDU(b) == '0A0102'O)and(enc_CER_PDU(b) == '0A0102'O)) {setverdict(pass);} else {setverdict(fail);}
11169 Overall verdict: pass
11175 .*---------------------------------------------------------------------*
11176 :h3. DER + CER encoding of ENUMERATED first
11177 .*---------------------------------------------------------------------*
11180 <TC - DER + CER encoding of ENUMERATED first>
11188 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11193 import from TempA all;
11194 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11195 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11197 const BERPDU b := first
11201 if ((enc_DER_PDU(b) == '0A0101'O)and(enc_CER_PDU(b) == '0A0101'O)) {setverdict(pass);} else {setverdict(fail);}
11205 Overall verdict: pass
11211 .*---------------------------------------------------------------------*
11212 :h3. DER + CER encoding of ENUMERATED second(0)
11213 .*---------------------------------------------------------------------*
11216 <TC - DER + CER encoding of ENUMERATED second(0)>
11224 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11229 import from TempA all;
11230 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11231 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11233 const BERPDU b := second
11237 if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);}
11241 Overall verdict: pass
11247 .*---------------------------------------------------------------------*
11248 :h3. DER + CER encoding of ENUMERATED third
11249 .*---------------------------------------------------------------------*
11252 <TC - DER + CER encoding of ENUMERATED third>
11260 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11265 import from TempA all;
11266 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11267 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11269 const BERPDU b := third
11273 if ((enc_DER_PDU(b) == '0A0102'O)and(enc_CER_PDU(b) == '0A0102'O)) {setverdict(pass);} else {setverdict(fail);}
11277 Overall verdict: pass
11283 .*---------------------------------------------------------------------*
11284 :h3. DER + CER encoding of ENUMERATED fourth (after extension ...)
11285 .*---------------------------------------------------------------------*
11288 <TC - DER + CER encoding of ENUMERATED fourth (after extension ...)>
11296 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11301 import from TempA all;
11302 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11303 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11305 const BERPDU b := fourth
11309 if ((enc_DER_PDU(b) == '0A0103'O)and(enc_CER_PDU(b) == '0A0103'O)) {setverdict(pass);} else {setverdict(fail);}
11313 Overall verdict: pass
11319 .*---------------------------------------------------------------------*
11320 :h3. DER + CER encoding of ENUMERATED fifth(5) (after extension ...)
11321 .*---------------------------------------------------------------------*
11324 <TC - DER + CER encoding of ENUMERATED fifth(5) (after extension ...)>
11332 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11337 import from TempA all;
11338 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11339 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11341 const BERPDU b := fifth
11345 if ((enc_DER_PDU(b) == '0A0105'O)and(enc_CER_PDU(b) == '0A0105'O)) {setverdict(pass);} else {setverdict(fail);}
11349 Overall verdict: pass
11355 .*---------------------------------------------------------------------*
11356 :h3. DER + CER encoding of ENUMERATED sixth (after extension ...)
11357 .*---------------------------------------------------------------------*
11360 <TC - DER + CER encoding of ENUMERATED sixth (after extension ...)>
11368 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11373 import from TempA all;
11374 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11375 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11377 const BERPDU b := sixth
11381 if ((enc_DER_PDU(b) == '0A0106'O)and(enc_CER_PDU(b) == '0A0106'O)) {setverdict(pass);} else {setverdict(fail);}
11385 Overall verdict: pass
11391 .*---------------------------------------------------------------------*
11392 :h3. DER + CER encoding of ENUMERATED , tagged, EXPLICIT
11393 .*---------------------------------------------------------------------*
11396 <TC - DER + CER encoding of ENUMERATED , tagged, EXPLICIT>
11404 BERPDU ::= [21] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11409 import from TempA all;
11410 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11411 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11413 const BERPDU b := sixth
11417 if ((enc_DER_PDU(b) == 'B5030A0106'O)and(enc_CER_PDU(b) == 'B5800A01060000'O)) {setverdict(pass);} else {setverdict(fail);}
11421 Overall verdict: pass
11427 .*---------------------------------------------------------------------*
11428 :h3. DER + CER encoding of ENUMERATED , tagged, IMPLICIT
11429 .*---------------------------------------------------------------------*
11432 <TC - DER + CER encoding of ENUMERATED , tagged, IMPLICIT>
11440 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11445 import from TempA all;
11446 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
11447 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
11449 const BERPDU b := sixth
11453 if ((enc_DER_PDU(b) == '9F580106'O)and(enc_CER_PDU(b) == '9F580106'O)) {setverdict(pass);} else {setverdict(fail);}
11457 Overall verdict: pass
11463 .*---------------------------------------------------------------------*
11464 :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (first)
11465 .*---------------------------------------------------------------------*
11468 <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (first)>
11469 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11477 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11480 myValue BERPDU ::= first
11488 import from TempA all;
11490 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11495 if (dec_BER_PDU('0A0101'O) == myValue)
11497 {setverdict(pass);} else {setverdict(fail);}
11502 Overall verdict: pass
11508 .*---------------------------------------------------------------------*
11509 :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (first)
11510 .*---------------------------------------------------------------------*
11513 <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (first)>
11514 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11522 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11525 myValue BERPDU ::= first
11533 import from TempA all;
11535 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11540 if (dec_BER_PDU('0A810101'O) == myValue)
11542 {setverdict(pass);} else {setverdict(fail);}
11547 Overall verdict: pass
11553 .*---------------------------------------------------------------------*
11554 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (first)
11555 .*---------------------------------------------------------------------*
11558 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (first)>
11559 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11567 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11570 myValue BERPDU ::= first
11578 import from TempA all;
11580 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11585 if (dec_BER_PDU('A0030A0101'O) == myValue)
11587 {setverdict(pass);} else {setverdict(fail);}
11592 Overall verdict: pass
11598 .*---------------------------------------------------------------------*
11599 :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (first)
11600 .*---------------------------------------------------------------------*
11603 <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (first)>
11604 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11612 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11615 myValue BERPDU ::= first
11623 import from TempA all;
11625 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11630 if (dec_BER_PDU('A0800A01010000'O) == myValue)
11632 {setverdict(pass);} else {setverdict(fail);}
11637 Overall verdict: pass
11643 .*---------------------------------------------------------------------*
11644 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (first)
11645 .*---------------------------------------------------------------------*
11648 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (first)>
11649 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11657 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11660 myValue BERPDU ::= first
11668 import from TempA all;
11670 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11675 if (dec_BER_PDU('A0040A810101'O) == myValue)
11677 {setverdict(pass);} else {setverdict(fail);}
11682 Overall verdict: pass
11688 .*---------------------------------------------------------------------*
11689 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (first)
11690 .*---------------------------------------------------------------------*
11693 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (first)>
11694 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11702 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11705 myValue BERPDU ::= first
11713 import from TempA all;
11715 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11720 if (dec_BER_PDU('A081040A810101'O) == myValue)
11722 {setverdict(pass);} else {setverdict(fail);}
11727 Overall verdict: pass
11733 .*---------------------------------------------------------------------*
11734 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (first)
11735 .*---------------------------------------------------------------------*
11738 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (first)>
11739 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11747 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11750 myValue BERPDU ::= first
11758 import from TempA all;
11760 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11765 if (dec_BER_PDU('9F580101'O) == myValue)
11767 {setverdict(pass);} else {setverdict(fail);}
11772 Overall verdict: pass
11778 .*---------------------------------------------------------------------*
11779 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (first)
11780 .*---------------------------------------------------------------------*
11783 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (first)>
11784 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11792 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11795 myValue BERPDU ::= first
11803 import from TempA all;
11805 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11810 if (dec_BER_PDU('9F58810101'O) == myValue)
11812 {setverdict(pass);} else {setverdict(fail);}
11817 Overall verdict: pass
11823 .*---------------------------------------------------------------------*
11824 :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (second(0))
11825 .*---------------------------------------------------------------------*
11828 <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (second(0))>
11829 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11837 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11840 myValue BERPDU ::= second
11848 import from TempA all;
11850 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11855 if (dec_BER_PDU('0A0100'O) == myValue)
11857 {setverdict(pass);} else {setverdict(fail);}
11862 Overall verdict: pass
11868 .*---------------------------------------------------------------------*
11869 :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (second(0))
11870 .*---------------------------------------------------------------------*
11873 <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (second(0))>
11874 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11882 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11885 myValue BERPDU ::= second
11893 import from TempA all;
11895 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11900 if (dec_BER_PDU('0A810100'O) == myValue)
11902 {setverdict(pass);} else {setverdict(fail);}
11907 Overall verdict: pass
11913 .*---------------------------------------------------------------------*
11914 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (second(0))
11915 .*---------------------------------------------------------------------*
11918 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (second(0))>
11919 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11927 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11930 myValue BERPDU ::= second
11938 import from TempA all;
11940 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11945 if (dec_BER_PDU('A0030A0100'O) == myValue)
11947 {setverdict(pass);} else {setverdict(fail);}
11952 Overall verdict: pass
11958 .*---------------------------------------------------------------------*
11959 :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (second(0))
11960 .*---------------------------------------------------------------------*
11963 <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (second(0))>
11964 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11972 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
11975 myValue BERPDU ::= second
11983 import from TempA all;
11985 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
11990 if (dec_BER_PDU('A0800A01000000'O) == myValue)
11992 {setverdict(pass);} else {setverdict(fail);}
11997 Overall verdict: pass
12003 .*---------------------------------------------------------------------*
12004 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (second(0))
12005 .*---------------------------------------------------------------------*
12008 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (second(0))>
12009 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12017 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12020 myValue BERPDU ::= second
12028 import from TempA all;
12030 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12035 if (dec_BER_PDU('A0040A810100'O) == myValue)
12037 {setverdict(pass);} else {setverdict(fail);}
12042 Overall verdict: pass
12048 .*---------------------------------------------------------------------*
12049 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (second(0))
12050 .*---------------------------------------------------------------------*
12053 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (second(0))>
12054 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12062 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12065 myValue BERPDU ::= second
12073 import from TempA all;
12075 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12080 if (dec_BER_PDU('A081040A810100'O) == myValue)
12082 {setverdict(pass);} else {setverdict(fail);}
12087 Overall verdict: pass
12093 .*---------------------------------------------------------------------*
12094 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (second(0))
12095 .*---------------------------------------------------------------------*
12098 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (second(0))>
12099 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12107 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12110 myValue BERPDU ::= second
12118 import from TempA all;
12120 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12125 if (dec_BER_PDU('9F580100'O) == myValue)
12127 {setverdict(pass);} else {setverdict(fail);}
12132 Overall verdict: pass
12138 .*---------------------------------------------------------------------*
12139 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (second(0))
12140 .*---------------------------------------------------------------------*
12143 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (second(0))>
12144 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12152 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12155 myValue BERPDU ::= second
12163 import from TempA all;
12165 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12170 if (dec_BER_PDU('9F58810100'O) == myValue)
12172 {setverdict(pass);} else {setverdict(fail);}
12177 Overall verdict: pass
12183 .*---------------------------------------------------------------------*
12184 :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (third)
12185 .*---------------------------------------------------------------------*
12188 <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (third)>
12189 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12197 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12200 myValue BERPDU ::= third
12208 import from TempA all;
12210 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12215 if (dec_BER_PDU('0A0102'O) == myValue)
12217 {setverdict(pass);} else {setverdict(fail);}
12222 Overall verdict: pass
12228 .*---------------------------------------------------------------------*
12229 :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (third)
12230 .*---------------------------------------------------------------------*
12233 <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (third)>
12234 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12242 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12245 myValue BERPDU ::= third
12253 import from TempA all;
12255 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12260 if (dec_BER_PDU('0A810102'O) == myValue)
12262 {setverdict(pass);} else {setverdict(fail);}
12267 Overall verdict: pass
12273 .*---------------------------------------------------------------------*
12274 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (third)
12275 .*---------------------------------------------------------------------*
12278 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (third)>
12279 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12287 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12290 myValue BERPDU ::= third
12298 import from TempA all;
12300 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12305 if (dec_BER_PDU('A0030A0102'O) == myValue)
12307 {setverdict(pass);} else {setverdict(fail);}
12312 Overall verdict: pass
12318 .*---------------------------------------------------------------------*
12319 :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (third)
12320 .*---------------------------------------------------------------------*
12323 <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (third)>
12324 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12332 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12335 myValue BERPDU ::= third
12343 import from TempA all;
12345 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12350 if (dec_BER_PDU('A0800A01020000'O) == myValue)
12352 {setverdict(pass);} else {setverdict(fail);}
12357 Overall verdict: pass
12363 .*---------------------------------------------------------------------*
12364 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (third)
12365 .*---------------------------------------------------------------------*
12368 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (third)>
12369 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12377 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12380 myValue BERPDU ::= third
12388 import from TempA all;
12390 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12395 if (dec_BER_PDU('A0040A810102'O) == myValue)
12397 {setverdict(pass);} else {setverdict(fail);}
12402 Overall verdict: pass
12408 .*---------------------------------------------------------------------*
12409 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (third)
12410 .*---------------------------------------------------------------------*
12413 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (third)>
12414 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12422 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12425 myValue BERPDU ::= third
12433 import from TempA all;
12435 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12440 if (dec_BER_PDU('A081040A810102'O) == myValue)
12442 {setverdict(pass);} else {setverdict(fail);}
12447 Overall verdict: pass
12453 .*---------------------------------------------------------------------*
12454 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (third)
12455 .*---------------------------------------------------------------------*
12458 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (third)>
12459 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12467 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12470 myValue BERPDU ::= third
12478 import from TempA all;
12480 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12485 if (dec_BER_PDU('9F580102'O) == myValue)
12487 {setverdict(pass);} else {setverdict(fail);}
12492 Overall verdict: pass
12498 .*---------------------------------------------------------------------*
12499 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (third)
12500 .*---------------------------------------------------------------------*
12503 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (third)>
12504 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12512 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12515 myValue BERPDU ::= third
12523 import from TempA all;
12525 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12530 if (dec_BER_PDU('9F58810102'O) == myValue)
12532 {setverdict(pass);} else {setverdict(fail);}
12537 Overall verdict: pass
12543 .*---------------------------------------------------------------------*
12544 :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (fourth)
12545 .*---------------------------------------------------------------------*
12548 <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (fourth)>
12549 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12557 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12560 myValue BERPDU ::= fourth
12568 import from TempA all;
12570 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12575 if (dec_BER_PDU('0A0103'O) == myValue)
12577 {setverdict(pass);} else {setverdict(fail);}
12582 Overall verdict: pass
12588 .*---------------------------------------------------------------------*
12589 :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (fourth)
12590 .*---------------------------------------------------------------------*
12593 <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (fourth)>
12594 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12602 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12605 myValue BERPDU ::= fourth
12613 import from TempA all;
12615 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12620 if (dec_BER_PDU('0A810103'O) == myValue)
12622 {setverdict(pass);} else {setverdict(fail);}
12627 Overall verdict: pass
12633 .*---------------------------------------------------------------------*
12634 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (fourth)
12635 .*---------------------------------------------------------------------*
12638 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (fourth)>
12639 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12647 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12650 myValue BERPDU ::= fourth
12658 import from TempA all;
12660 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12665 if (dec_BER_PDU('A0030A0103'O) == myValue)
12667 {setverdict(pass);} else {setverdict(fail);}
12672 Overall verdict: pass
12678 .*---------------------------------------------------------------------*
12679 :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (fourth)
12680 .*---------------------------------------------------------------------*
12683 <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (fourth)>
12684 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12692 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12695 myValue BERPDU ::= fourth
12703 import from TempA all;
12705 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12710 if (dec_BER_PDU('A0800A01030000'O) == myValue)
12712 {setverdict(pass);} else {setverdict(fail);}
12717 Overall verdict: pass
12723 .*---------------------------------------------------------------------*
12724 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (fourth)
12725 .*---------------------------------------------------------------------*
12728 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (fourth)>
12729 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12737 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12740 myValue BERPDU ::= fourth
12748 import from TempA all;
12750 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12755 if (dec_BER_PDU('A0040A810103'O) == myValue)
12757 {setverdict(pass);} else {setverdict(fail);}
12762 Overall verdict: pass
12768 .*---------------------------------------------------------------------*
12769 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (fourth)
12770 .*---------------------------------------------------------------------*
12773 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (fourth)>
12774 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12782 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12785 myValue BERPDU ::= fourth
12793 import from TempA all;
12795 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12800 if (dec_BER_PDU('A081040A810103'O) == myValue)
12802 {setverdict(pass);} else {setverdict(fail);}
12807 Overall verdict: pass
12813 .*---------------------------------------------------------------------*
12814 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (fourth)
12815 .*---------------------------------------------------------------------*
12818 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (fourth)>
12819 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12827 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12830 myValue BERPDU ::= fourth
12838 import from TempA all;
12840 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12845 if (dec_BER_PDU('9F580103'O) == myValue)
12847 {setverdict(pass);} else {setverdict(fail);}
12852 Overall verdict: pass
12858 .*---------------------------------------------------------------------*
12859 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (fourth)
12860 .*---------------------------------------------------------------------*
12863 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (fourth)>
12864 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12872 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12875 myValue BERPDU ::= fourth
12883 import from TempA all;
12885 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12890 if (dec_BER_PDU('9F58810103'O) == myValue)
12892 {setverdict(pass);} else {setverdict(fail);}
12897 Overall verdict: pass
12903 .*---------------------------------------------------------------------*
12904 :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (fifth(5))
12905 .*---------------------------------------------------------------------*
12908 <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (fifth(5))>
12909 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12917 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12920 myValue BERPDU ::= fifth
12928 import from TempA all;
12930 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12935 if (dec_BER_PDU('0A0105'O) == myValue)
12937 {setverdict(pass);} else {setverdict(fail);}
12942 Overall verdict: pass
12948 .*---------------------------------------------------------------------*
12949 :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (fifth(5))
12950 .*---------------------------------------------------------------------*
12953 <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (fifth(5))>
12954 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12962 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
12965 myValue BERPDU ::= fifth
12973 import from TempA all;
12975 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
12980 if (dec_BER_PDU('0A810105'O) == myValue)
12982 {setverdict(pass);} else {setverdict(fail);}
12987 Overall verdict: pass
12993 .*---------------------------------------------------------------------*
12994 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (fifth(5))
12995 .*---------------------------------------------------------------------*
12998 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (fifth(5))>
12999 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13007 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13010 myValue BERPDU ::= fifth
13018 import from TempA all;
13020 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13025 if (dec_BER_PDU('A0030A0105'O) == myValue)
13027 {setverdict(pass);} else {setverdict(fail);}
13032 Overall verdict: pass
13038 .*---------------------------------------------------------------------*
13039 :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (fifth(5))
13040 .*---------------------------------------------------------------------*
13043 <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (fifth(5))>
13044 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13052 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13055 myValue BERPDU ::= fifth
13063 import from TempA all;
13065 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13070 if (dec_BER_PDU('A0800A01050000'O) == myValue)
13072 {setverdict(pass);} else {setverdict(fail);}
13077 Overall verdict: pass
13083 .*---------------------------------------------------------------------*
13084 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (fifth(5))
13085 .*---------------------------------------------------------------------*
13088 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (fifth(5))>
13089 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13097 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13100 myValue BERPDU ::= fifth
13108 import from TempA all;
13110 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13115 if (dec_BER_PDU('A0040A810105'O) == myValue)
13117 {setverdict(pass);} else {setverdict(fail);}
13122 Overall verdict: pass
13128 .*---------------------------------------------------------------------*
13129 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (fifth(5))
13130 .*---------------------------------------------------------------------*
13133 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (fifth(5))>
13134 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13142 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13145 myValue BERPDU ::= fifth
13153 import from TempA all;
13155 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13160 if (dec_BER_PDU('A081040A810105'O) == myValue)
13162 {setverdict(pass);} else {setverdict(fail);}
13167 Overall verdict: pass
13173 .*---------------------------------------------------------------------*
13174 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (fifth(5))
13175 .*---------------------------------------------------------------------*
13178 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (fifth(5))>
13179 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13187 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13190 myValue BERPDU ::= fifth
13198 import from TempA all;
13200 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13205 if (dec_BER_PDU('9F580105'O) == myValue)
13207 {setverdict(pass);} else {setverdict(fail);}
13212 Overall verdict: pass
13218 .*---------------------------------------------------------------------*
13219 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (fifth(5))
13220 .*---------------------------------------------------------------------*
13223 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (fifth(5))>
13224 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13232 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13235 myValue BERPDU ::= fifth
13243 import from TempA all;
13245 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13250 if (dec_BER_PDU('9F58810105'O) == myValue)
13252 {setverdict(pass);} else {setverdict(fail);}
13257 Overall verdict: pass
13263 .*---------------------------------------------------------------------*
13264 :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (sixth)
13265 .*---------------------------------------------------------------------*
13268 <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (sixth)>
13269 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13277 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13280 myValue BERPDU ::= sixth
13288 import from TempA all;
13290 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13295 if (dec_BER_PDU('0A0106'O) == myValue)
13297 {setverdict(pass);} else {setverdict(fail);}
13302 Overall verdict: pass
13308 .*---------------------------------------------------------------------*
13309 :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (sixth)
13310 .*---------------------------------------------------------------------*
13313 <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (sixth)>
13314 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13322 BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13325 myValue BERPDU ::= sixth
13333 import from TempA all;
13335 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13340 if (dec_BER_PDU('0A810106'O) == myValue)
13342 {setverdict(pass);} else {setverdict(fail);}
13347 Overall verdict: pass
13353 .*---------------------------------------------------------------------*
13354 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (sixth)
13355 .*---------------------------------------------------------------------*
13358 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (sixth)>
13359 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13367 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13370 myValue BERPDU ::= sixth
13378 import from TempA all;
13380 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13385 if (dec_BER_PDU('A0030A0106'O) == myValue)
13387 {setverdict(pass);} else {setverdict(fail);}
13392 Overall verdict: pass
13398 .*---------------------------------------------------------------------*
13399 :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (sixth)
13400 .*---------------------------------------------------------------------*
13403 <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (sixth)>
13404 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13412 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13415 myValue BERPDU ::= sixth
13423 import from TempA all;
13425 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13430 if (dec_BER_PDU('A0800A01060000'O) == myValue)
13432 {setverdict(pass);} else {setverdict(fail);}
13437 Overall verdict: pass
13443 .*---------------------------------------------------------------------*
13444 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (sixth)
13445 .*---------------------------------------------------------------------*
13448 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (sixth)>
13449 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13457 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13460 myValue BERPDU ::= sixth
13468 import from TempA all;
13470 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13475 if (dec_BER_PDU('A0040A810106'O) == myValue)
13477 {setverdict(pass);} else {setverdict(fail);}
13482 Overall verdict: pass
13488 .*---------------------------------------------------------------------*
13489 :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (sixth)
13490 .*---------------------------------------------------------------------*
13493 <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (sixth)>
13494 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13502 BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13505 myValue BERPDU ::= sixth
13513 import from TempA all;
13515 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13520 if (dec_BER_PDU('A081040A810106'O) == myValue)
13522 {setverdict(pass);} else {setverdict(fail);}
13527 Overall verdict: pass
13533 .*---------------------------------------------------------------------*
13534 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (sixth)
13535 .*---------------------------------------------------------------------*
13538 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (sixth)>
13539 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13547 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13550 myValue BERPDU ::= sixth
13558 import from TempA all;
13560 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13565 if (dec_BER_PDU('9F580106'O) == myValue)
13567 {setverdict(pass);} else {setverdict(fail);}
13572 Overall verdict: pass
13578 .*---------------------------------------------------------------------*
13579 :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (sixth)
13580 .*---------------------------------------------------------------------*
13583 <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (sixth)>
13584 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13592 BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth}
13595 myValue BERPDU ::= sixth
13603 import from TempA all;
13605 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
13610 if (dec_BER_PDU('9F58810106'O) == myValue)
13612 {setverdict(pass);} else {setverdict(fail);}
13617 Overall verdict: pass
13623 .*---------------------------------------------------------------------*
13624 :h3.CER + DER encoding of REAL, 0 (primitive)
13625 .*---------------------------------------------------------------------*
13628 <TC - CER + DER encoding of REAL, 0 (primitive)>
13643 import from TempA all;
13644 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13645 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13651 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13655 Overall verdict: pass
13661 .*---------------------------------------------------------------------*
13662 :h3.CER + DER encoding of REAL, 0.0 (primitive)
13663 .*---------------------------------------------------------------------*
13666 <TC - CER + DER encoding of REAL, 0.0 (primitive)>
13681 import from TempA all;
13682 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13683 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13689 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13693 Overall verdict: pass
13699 .*---------------------------------------------------------------------*
13700 :h3.CER + DER encoding of REAL, 0E0 (primitive)
13701 .*---------------------------------------------------------------------*
13704 <TC - CER + DER encoding of REAL, 0E0 (primitive)>
13719 import from TempA all;
13720 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13721 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13727 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13731 Overall verdict: pass
13737 .*---------------------------------------------------------------------*
13738 :h3.CER + DER encoding of REAL, 0.0E0 (primitive)
13739 .*---------------------------------------------------------------------*
13742 <TC - CER + DER encoding of REAL, 0.0E0 (primitive)>
13757 import from TempA all;
13758 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13759 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13765 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13769 Overall verdict: pass
13775 .*---------------------------------------------------------------------*
13776 :h3.CER + DER encoding of REAL, 0e0 (primitive)
13777 .*---------------------------------------------------------------------*
13780 <TC - CER + DER encoding of REAL, 0e0 (primitive)>
13795 import from TempA all;
13796 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13797 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13803 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13807 Overall verdict: pass
13813 .*---------------------------------------------------------------------*
13814 :h3.CER + DER encoding of REAL, 0.0e0 (primitive)
13815 .*---------------------------------------------------------------------*
13818 <TC - CER + DER encoding of REAL, 0.0e0 (primitive)>
13833 import from TempA all;
13834 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13835 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13841 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13845 Overall verdict: pass
13851 .*---------------------------------------------------------------------*
13852 :h3.CER + DER encoding of REAL, 0E+0 (primitive)
13853 .*---------------------------------------------------------------------*
13856 <TC - CER + DER encoding of REAL, 0E+0 (primitive)>
13871 import from TempA all;
13872 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13873 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13879 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13883 Overall verdict: pass
13889 .*---------------------------------------------------------------------*
13890 :h3.CER + DER encoding of REAL, 0.0E+0 (primitive)
13891 .*---------------------------------------------------------------------*
13894 <TC - CER + DER encoding of REAL, 0.0E+0 (primitive)>
13903 b BERPDU ::= 0.0E+0
13909 import from TempA all;
13910 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13911 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13917 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13921 Overall verdict: pass
13927 .*---------------------------------------------------------------------*
13928 :h3.CER + DER encoding of REAL, 0e+0 (primitive)
13929 .*---------------------------------------------------------------------*
13932 <TC - CER + DER encoding of REAL, 0e+0 (primitive)>
13947 import from TempA all;
13948 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13949 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13955 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13959 Overall verdict: pass
13965 .*---------------------------------------------------------------------*
13966 :h3.CER + DER encoding of REAL, 0.0e+0 (primitive)
13967 .*---------------------------------------------------------------------*
13970 <TC - CER + DER encoding of REAL, 0.0e+0 (primitive)>
13979 b BERPDU ::= 0.0e+0
13985 import from TempA all;
13986 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
13987 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
13993 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
13997 Overall verdict: pass
14003 .*---------------------------------------------------------------------*
14004 :h3.CER + DER encoding of REAL, 0E-0 (primitive)
14005 .*---------------------------------------------------------------------*
14008 <TC - CER + DER encoding of REAL, 0E-0 (primitive)>
14023 import from TempA all;
14024 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14025 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14031 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
14035 Overall verdict: pass
14041 .*---------------------------------------------------------------------*
14042 :h3.CER + DER encoding of REAL, 0.0E-0 (primitive)
14043 .*---------------------------------------------------------------------*
14046 <TC - CER + DER encoding of REAL, 0.0E-0 (primitive)>
14055 b BERPDU ::= 0.0E-0
14061 import from TempA all;
14062 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14063 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14069 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
14073 Overall verdict: pass
14079 .*---------------------------------------------------------------------*
14080 :h3.CER + DER encoding of REAL, 0e-0 (primitive)
14081 .*---------------------------------------------------------------------*
14084 <TC - CER + DER encoding of REAL, 0e-0 (primitive)>
14099 import from TempA all;
14100 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14101 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14107 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
14111 Overall verdict: pass
14117 .*---------------------------------------------------------------------*
14118 :h3.CER + DER encoding of REAL, 0.0e-0 (primitive)
14119 .*---------------------------------------------------------------------*
14122 <TC - CER + DER encoding of REAL, 0.0e-0 (primitive)>
14131 b BERPDU ::= 0.0e-0
14137 import from TempA all;
14138 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14139 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14145 if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);}
14149 Overall verdict: pass
14155 .*---------------------------------------------------------------------*
14156 :h3.CER + DER encoding of REAL, 1 (primitive)
14157 .*---------------------------------------------------------------------*
14160 <TC - CER + DER encoding of REAL, 1 (primitive)>
14175 import from TempA all;
14176 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14177 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14183 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14187 Overall verdict: pass
14193 .*---------------------------------------------------------------------*
14194 :h3.CER + DER encoding of REAL, 1e0 (primitive)
14195 .*---------------------------------------------------------------------*
14198 <TC - CER + DER encoding of REAL, 1e0 (primitive)>
14213 import from TempA all;
14214 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14215 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14221 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14225 Overall verdict: pass
14231 .*---------------------------------------------------------------------*
14232 :h3.CER + DER encoding of REAL, 1E0 (primitive)
14233 .*---------------------------------------------------------------------*
14236 <TC - CER + DER encoding of REAL, 1E0 (primitive)>
14251 import from TempA all;
14252 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14253 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14259 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14263 Overall verdict: pass
14269 .*---------------------------------------------------------------------*
14270 :h3.CER + DER encoding of REAL, 1.0e0 (primitive)
14271 .*---------------------------------------------------------------------*
14274 <TC - CER + DER encoding of REAL, 1.0e0 (primitive)>
14289 import from TempA all;
14290 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14291 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14297 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14301 Overall verdict: pass
14307 .*---------------------------------------------------------------------*
14308 :h3.CER + DER encoding of REAL, 1.0E0 (primitive)
14309 .*---------------------------------------------------------------------*
14312 <TC - CER + DER encoding of REAL, 1.0E0 (primitive)>
14327 import from TempA all;
14328 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14329 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14335 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14339 Overall verdict: pass
14345 .*---------------------------------------------------------------------*
14346 :h3.CER + DER encoding of REAL, 1e+0 (primitive)
14347 .*---------------------------------------------------------------------*
14350 <TC - CER + DER encoding of REAL, 1e+0 (primitive)>
14365 import from TempA all;
14366 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14367 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14373 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14377 Overall verdict: pass
14383 .*---------------------------------------------------------------------*
14384 :h3.CER + DER encoding of REAL, 1E+0 (primitive)
14385 .*---------------------------------------------------------------------*
14388 <TC - CER + DER encoding of REAL, 1E+0 (primitive)>
14403 import from TempA all;
14404 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14405 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14411 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14415 Overall verdict: pass
14421 .*---------------------------------------------------------------------*
14422 :h3.CER + DER encoding of REAL, 1.0e+0 (primitive)
14423 .*---------------------------------------------------------------------*
14426 <TC - CER + DER encoding of REAL, 1.0e+0 (primitive)>
14435 b BERPDU ::= 1.0e+0
14441 import from TempA all;
14442 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14443 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14449 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14453 Overall verdict: pass
14459 .*---------------------------------------------------------------------*
14460 :h3.CER + DER encoding of REAL, 1.0E+0 (primitive)
14461 .*---------------------------------------------------------------------*
14464 <TC - CER + DER encoding of REAL, 1.0E+0 (primitive)>
14473 b BERPDU ::= 1.0E+0
14479 import from TempA all;
14480 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14481 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14487 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14491 Overall verdict: pass
14497 .*---------------------------------------------------------------------*
14498 :h3.CER + DER encoding of REAL, 1e-0 (primitive)
14499 .*---------------------------------------------------------------------*
14502 <TC - CER + DER encoding of REAL, 1e-0 (primitive)>
14517 import from TempA all;
14518 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14519 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14525 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14529 Overall verdict: pass
14535 .*---------------------------------------------------------------------*
14536 :h3.CER + DER encoding of REAL, 1E-0 (primitive)
14537 .*---------------------------------------------------------------------*
14540 <TC - CER + DER encoding of REAL, 1E-0 (primitive)>
14555 import from TempA all;
14556 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14557 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14563 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14567 Overall verdict: pass
14573 .*---------------------------------------------------------------------*
14574 :h3.CER + DER encoding of REAL, 1.0e-0 (primitive)
14575 .*---------------------------------------------------------------------*
14578 <TC - CER + DER encoding of REAL, 1.0e-0 (primitive)>
14587 b BERPDU ::= 1.0e-0
14593 import from TempA all;
14594 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14595 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14601 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14605 Overall verdict: pass
14611 .*---------------------------------------------------------------------*
14612 :h3.CER + DER encoding of REAL, 1.0E-0 (primitive)
14613 .*---------------------------------------------------------------------*
14616 <TC - CER + DER encoding of REAL, 1.0E-0 (primitive)>
14625 b BERPDU ::= 1.0E-0
14631 import from TempA all;
14632 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14633 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14639 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14643 Overall verdict: pass
14649 .*---------------------------------------------------------------------*
14650 :h3.CER + DER encoding of REAL, 2 (primitive)
14651 .*---------------------------------------------------------------------*
14654 <TC - CER + DER encoding of REAL, 2 (primitive)>
14669 import from TempA all;
14670 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14671 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14677 if ((enc_DER_PDU(b) == '090603322E452B30'O)and(enc_CER_PDU(b) == '090603322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14681 Overall verdict: pass
14687 .*---------------------------------------------------------------------*
14688 :h3.CER + DER encoding of REAL, 2.0 (primitive)
14689 .*---------------------------------------------------------------------*
14692 <TC - CER + DER encoding of REAL, 2.0 (primitive)>
14707 import from TempA all;
14708 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14709 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14715 if ((enc_DER_PDU(b) == '090603322E452B30'O)and(enc_CER_PDU(b) == '090603322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14719 Overall verdict: pass
14725 .*---------------------------------------------------------------------*
14726 :h3.CER + DER encoding of REAL, -1 (primitive)
14727 .*---------------------------------------------------------------------*
14730 <TC - CER + DER encoding of REAL, -1 (primitive)>
14745 import from TempA all;
14746 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14747 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14753 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14757 Overall verdict: pass
14763 .*---------------------------------------------------------------------*
14764 :h3.CER + DER encoding of REAL, -1e0 (primitive)
14765 .*---------------------------------------------------------------------*
14768 <TC - CER + DER encoding of REAL, -1e0 (primitive)>
14783 import from TempA all;
14784 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14785 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14791 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14795 Overall verdict: pass
14801 .*---------------------------------------------------------------------*
14802 :h3.CER + DER encoding of REAL, -1E0 (primitive)
14803 .*---------------------------------------------------------------------*
14806 <TC - CER + DER encoding of REAL, -1E0 (primitive)>
14821 import from TempA all;
14822 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14823 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14829 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14833 Overall verdict: pass
14839 .*---------------------------------------------------------------------*
14840 :h3.CER + DER encoding of REAL, -1.0e0 (primitive)
14841 .*---------------------------------------------------------------------*
14844 <TC - CER + DER encoding of REAL, -1.0e0 (primitive)>
14853 b BERPDU ::= -1.0e0
14859 import from TempA all;
14860 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14861 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14867 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14871 Overall verdict: pass
14877 .*---------------------------------------------------------------------*
14878 :h3.CER + DER encoding of REAL, -1.0E0 (primitive)
14879 .*---------------------------------------------------------------------*
14882 <TC - CER + DER encoding of REAL, -1.0E0 (primitive)>
14891 b BERPDU ::= -1.0E0
14897 import from TempA all;
14898 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14899 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14905 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14909 Overall verdict: pass
14915 .*---------------------------------------------------------------------*
14916 :h3.CER + DER encoding of REAL, -1e+0 (primitive)
14917 .*---------------------------------------------------------------------*
14920 <TC - CER + DER encoding of REAL, -1e+0 (primitive)>
14935 import from TempA all;
14936 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14937 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14943 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14947 Overall verdict: pass
14953 .*---------------------------------------------------------------------*
14954 :h3.CER + DER encoding of REAL, -1E+0 (primitive)
14955 .*---------------------------------------------------------------------*
14958 <TC - CER + DER encoding of REAL, -1E+0 (primitive)>
14973 import from TempA all;
14974 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
14975 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
14981 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
14985 Overall verdict: pass
14991 .*---------------------------------------------------------------------*
14992 :h3.CER + DER encoding of REAL, -1.0e+0 (primitive)
14993 .*---------------------------------------------------------------------*
14996 <TC - CER + DER encoding of REAL, -1.0e+0 (primitive)>
15005 b BERPDU ::= -1.0e+0
15011 import from TempA all;
15012 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15013 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15019 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15023 Overall verdict: pass
15029 .*---------------------------------------------------------------------*
15030 :h3.CER + DER encoding of REAL, -1.0E+0 (primitive)
15031 .*---------------------------------------------------------------------*
15034 <TC - CER + DER encoding of REAL, -1.0E+0 (primitive)>
15043 b BERPDU ::= -1.0E+0
15049 import from TempA all;
15050 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15051 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15057 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15061 Overall verdict: pass
15067 .*---------------------------------------------------------------------*
15068 :h3.CER + DER encoding of REAL, -1e-0 (primitive)
15069 .*---------------------------------------------------------------------*
15072 <TC - CER + DER encoding of REAL, -1e-0 (primitive)>
15087 import from TempA all;
15088 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15089 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15095 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15099 Overall verdict: pass
15105 .*---------------------------------------------------------------------*
15106 :h3.CER + DER encoding of REAL, -1E-0 (primitive)
15107 .*---------------------------------------------------------------------*
15110 <TC - CER + DER encoding of REAL, -1E-0 (primitive)>
15125 import from TempA all;
15126 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15127 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15133 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15137 Overall verdict: pass
15143 .*---------------------------------------------------------------------*
15144 :h3.CER + DER encoding of REAL, -1.0e-0 (primitive)
15145 .*---------------------------------------------------------------------*
15148 <TC - CER + DER encoding of REAL, -1.0e-0 (primitive)>
15157 b BERPDU ::= -1.0e-0
15163 import from TempA all;
15164 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15165 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15171 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15175 Overall verdict: pass
15181 .*---------------------------------------------------------------------*
15182 :h3.CER + DER encoding of REAL, -1.0E-0 (primitive)
15183 .*---------------------------------------------------------------------*
15186 <TC - CER + DER encoding of REAL, -1.0E-0 (primitive)>
15195 b BERPDU ::= -1.0E-0
15201 import from TempA all;
15202 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15203 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15209 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15213 Overall verdict: pass
15219 .*---------------------------------------------------------------------*
15220 :h3.CER + DER encoding of REAL, -1.0 (primitive)
15221 .*---------------------------------------------------------------------*
15224 <TC - CER + DER encoding of REAL, -1.0 (primitive)>
15239 import from TempA all;
15240 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15241 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15247 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15251 Overall verdict: pass
15257 .*---------------------------------------------------------------------*
15258 :h3.CER + DER encoding of REAL, 1.000 (primitive)
15259 .*---------------------------------------------------------------------*
15262 <TC - CER + DER encoding of REAL, 1.000 (primitive)>
15277 import from TempA all;
15278 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15279 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15285 if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15289 Overall verdict: pass
15295 .*---------------------------------------------------------------------*
15296 :h3.CER + DER encoding of REAL, -1.000 (primitive)
15297 .*---------------------------------------------------------------------*
15300 <TC - CER + DER encoding of REAL, -1.000 (primitive)>
15309 b BERPDU ::= -1.000
15315 import from TempA all;
15316 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15317 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15323 if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15327 Overall verdict: pass
15333 .*---------------------------------------------------------------------*
15334 :h3.CER + DER encoding of REAL, 12 (primitive)
15335 .*---------------------------------------------------------------------*
15338 <TC - CER + DER encoding of REAL, 12 (primitive)>
15353 import from TempA all;
15354 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15355 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15361 if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15365 Overall verdict: pass
15371 .*---------------------------------------------------------------------*
15372 :h3.CER + DER encoding of REAL, 12.0 (primitive)
15373 .*---------------------------------------------------------------------*
15376 <TC - CER + DER encoding of REAL, 12.0 (primitive)>
15391 import from TempA all;
15392 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15393 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15399 if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15403 Overall verdict: pass
15409 .*---------------------------------------------------------------------*
15410 :h3.CER + DER encoding of REAL, 12.0E0 (primitive)
15411 .*---------------------------------------------------------------------*
15414 <TC - CER + DER encoding of REAL, 12.0E0 (primitive)>
15423 b BERPDU ::= 12.0E0
15429 import from TempA all;
15430 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15431 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15437 if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15441 Overall verdict: pass
15447 .*---------------------------------------------------------------------*
15448 :h3.CER + DER encoding of REAL, 1.2E1 (primitive)
15449 .*---------------------------------------------------------------------*
15452 <TC - CER + DER encoding of REAL, 1.2E1 (primitive)>
15467 import from TempA all;
15468 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15469 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15475 if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15479 Overall verdict: pass
15485 .*---------------------------------------------------------------------*
15486 :h3.CER + DER encoding of REAL, 0.12E2 (primitive)
15487 .*---------------------------------------------------------------------*
15490 <TC - CER + DER encoding of REAL, 0.12E2 (primitive)>
15499 b BERPDU ::= 0.12E2
15505 import from TempA all;
15506 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15507 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15513 if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15517 Overall verdict: pass
15523 .*---------------------------------------------------------------------*
15524 :h3.CER + DER encoding of REAL, 1.2E+1 (primitive)
15525 .*---------------------------------------------------------------------*
15528 <TC - CER + DER encoding of REAL, 1.2E+1 (primitive)>
15543 import from TempA all;
15544 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15545 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15551 if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15555 Overall verdict: pass
15561 .*---------------------------------------------------------------------*
15562 :h3.CER + DER encoding of REAL, 0.12E+2 (primitive)
15563 .*---------------------------------------------------------------------*
15566 <TC - CER + DER encoding of REAL, 0.12E+2 (primitive)>
15575 b BERPDU ::= 0.12E2
15581 import from TempA all;
15582 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15583 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15589 if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15593 Overall verdict: pass
15599 .*---------------------------------------------------------------------*
15600 :h3.CER + DER encoding of REAL, 0.34 (primitive)
15601 .*---------------------------------------------------------------------*
15604 <TC - CER + DER encoding of REAL, 0.34 (primitive)>
15619 import from TempA all;
15620 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15621 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15627 if ((enc_DER_PDU(b) == '09070333342E452D32'O)and(enc_CER_PDU(b) == '09070333342E452D32'O)) {setverdict(pass);} else {setverdict(fail);}
15631 Overall verdict: pass
15637 .*---------------------------------------------------------------------*
15638 :h3.CER + DER encoding of REAL, 0.344 (primitive)
15639 .*---------------------------------------------------------------------*
15642 <TC - CER + DER encoding of REAL, 0.344 (primitive)>
15657 import from TempA all;
15658 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15659 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15665 if ((enc_DER_PDU(b) == '0908033334342E452D33'O)and(enc_CER_PDU(b) == '0908033334342E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
15669 Overall verdict: pass
15675 .*---------------------------------------------------------------------*
15676 :h3.CER + DER encoding of REAL, 0.345 (primitive)
15677 .*---------------------------------------------------------------------*
15680 <TC - CER + DER encoding of REAL, 0.345 (primitive)>
15695 import from TempA all;
15696 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15697 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15703 if ((enc_DER_PDU(b) == '0908033334352E452D33'O)and(enc_CER_PDU(b) == '0908033334352E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
15707 Overall verdict: pass
15713 .*---------------------------------------------------------------------*
15714 :h3.CER + DER encoding of REAL, 0.034 (primitive)
15715 .*---------------------------------------------------------------------*
15718 <TC - CER + DER encoding of REAL, 0.034 (primitive)>
15733 import from TempA all;
15734 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15735 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15741 if ((enc_DER_PDU(b) == '09070333342E452D33'O)and(enc_CER_PDU(b) == '09070333342E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
15745 Overall verdict: pass
15751 .*---------------------------------------------------------------------*
15752 :h3.CER + DER encoding of REAL, 0.0034 (primitive)
15753 .*---------------------------------------------------------------------*
15756 <TC - CER + DER encoding of REAL, 0.0034 (primitive)>
15765 b BERPDU ::= 0.0034
15771 import from TempA all;
15772 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15773 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15779 if ((enc_DER_PDU(b) == '09070333342E452D34'O)and(enc_CER_PDU(b) == '09070333342E452D34'O)) {setverdict(pass);} else {setverdict(fail);}
15783 Overall verdict: pass
15789 .*---------------------------------------------------------------------*
15790 :h3.CER + DER encoding of REAL, 0.304 (primitive)
15791 .*---------------------------------------------------------------------*
15794 <TC - CER + DER encoding of REAL, 0.304 (primitive)>
15809 import from TempA all;
15810 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15811 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15817 if ((enc_DER_PDU(b) == '0908033330342E452D33'O)and(enc_CER_PDU(b) == '0908033330342E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
15821 Overall verdict: pass
15827 .*---------------------------------------------------------------------*
15828 :h3.CER + DER encoding of REAL, 0.1234567890 (primitive)
15829 .*---------------------------------------------------------------------*
15832 <TC - CER + DER encoding of REAL, 0.1234567890 (primitive)>
15841 b BERPDU ::= 0.1234567890
15847 import from TempA all;
15848 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15849 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15855 if ((enc_DER_PDU(b) == '090E033132333435363738392E452D39'O)and(enc_CER_PDU(b) == '090E033132333435363738392E452D39'O)) {setverdict(pass);} else {setverdict(fail);}
15859 Overall verdict: pass
15865 .*---------------------------------------------------------------------*
15866 :h3.CER + DER encoding of REAL, 0.123456789 (primitive)
15867 .*---------------------------------------------------------------------*
15870 <TC - CER + DER encoding of REAL, 0.123456789 (primitive)>
15879 b BERPDU ::= 0.123456789
15885 import from TempA all;
15886 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15887 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15893 if ((enc_DER_PDU(b) == '090E033132333435363738392E452D39'O)and(enc_CER_PDU(b) == '090E033132333435363738392E452D39'O)) {setverdict(pass);} else {setverdict(fail);}
15897 Overall verdict: pass
15903 .*---------------------------------------------------------------------*
15904 :h3.CER + DER encoding of REAL, 0.0123456789 (primitive)
15905 .*---------------------------------------------------------------------*
15908 <TC - CER + DER encoding of REAL, 0.0123456789 (primitive)>
15917 b BERPDU ::= 0.0123456789
15923 import from TempA all;
15924 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15925 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15931 if ((enc_DER_PDU(b) == '090F033132333435363738392E452D3130'O)and(enc_CER_PDU(b) == '090F033132333435363738392E452D3130'O)) {setverdict(pass);} else {setverdict(fail);}
15935 Overall verdict: pass
15941 .*---------------------------------------------------------------------*
15942 :h3.CER + DER encoding of REAL, 123456789.0 (primitive)
15943 .*---------------------------------------------------------------------*
15946 <TC - CER + DER encoding of REAL, 123456789.0 (primitive)>
15955 b BERPDU ::= 123456789.0
15961 import from TempA all;
15962 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
15963 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
15969 if ((enc_DER_PDU(b) == '090E033132333435363738392E452B30'O)and(enc_CER_PDU(b) == '090E033132333435363738392E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
15973 Overall verdict: pass
15979 .*---------------------------------------------------------------------*
15980 :h3.CER + DER encoding of REAL, 123456789 (primitive)
15981 .*---------------------------------------------------------------------*
15984 <TC - CER + DER encoding of REAL, 123456789 (primitive)>
15993 b BERPDU ::= 123456789
15999 import from TempA all;
16000 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16001 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16007 if ((enc_DER_PDU(b) == '090E033132333435363738392E452B30'O)and(enc_CER_PDU(b) == '090E033132333435363738392E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16011 Overall verdict: pass
16017 .*---------------------------------------------------------------------*
16018 :h3.CER + DER encoding of REAL, 1234567890 (primitive)
16019 .*---------------------------------------------------------------------*
16022 <TC - CER + DER encoding of REAL, 1234567890 (primitive)>
16031 b BERPDU ::= 1234567890
16037 import from TempA all;
16038 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16039 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16045 if ((enc_DER_PDU(b) == '090D033132333435363738392E4531'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);}
16049 Overall verdict: pass
16055 .*---------------------------------------------------------------------*
16056 :h3.CER + DER encoding of REAL, 1234567890.0 (primitive)
16057 .*---------------------------------------------------------------------*
16060 <TC - CER + DER encoding of REAL, 1234567890.0 (primitive)>
16069 b BERPDU ::= 1234567890.0
16075 import from TempA all;
16076 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16077 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16083 if ((enc_DER_PDU(b) == '090D033132333435363738392E4531'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);}
16087 Overall verdict: pass
16093 .*---------------------------------------------------------------------*
16094 :h3.CER + DER encoding of REAL, 1234567890.00 (primitive)
16095 .*---------------------------------------------------------------------*
16098 <TC - CER + DER encoding of REAL, 1234567890.00 (primitive)>
16107 b BERPDU ::= 1234567890.00
16113 import from TempA all;
16114 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16115 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16121 if ((enc_DER_PDU(b) == '090D033132333435363738392E4531'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);}
16125 Overall verdict: pass
16131 .*---------------------------------------------------------------------*
16132 :h3.CER + DER encoding of REAL, 12345678900.0 (primitive)
16133 .*---------------------------------------------------------------------*
16136 <TC - CER + DER encoding of REAL, 12345678900.0 (primitive)>
16145 b BERPDU ::= 12345678900.0
16151 import from TempA all;
16152 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16153 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16159 if ((enc_DER_PDU(b) == '090D033132333435363738392E4532'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);}
16163 Overall verdict: pass
16169 .*---------------------------------------------------------------------*
16170 :h3.CER + DER encoding of REAL, 12345678900.0 (primitive)
16171 .*---------------------------------------------------------------------*
16174 <TC - CER + DER encoding of REAL, 12345678900.0 (primitive)>
16183 b BERPDU ::=12345678900.0
16189 import from TempA all;
16190 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16191 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16197 if ((enc_DER_PDU(b) == '090D033132333435363738392E4532'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);}
16201 Overall verdict: pass
16207 .*---------------------------------------------------------------------*
16208 :h3.CER + DER encoding of REAL, 12345678900.00 (primitive)
16209 .*---------------------------------------------------------------------*
16212 <TC - CER + DER encoding of REAL, 12345678900.00 (primitive)>
16221 b BERPDU ::= 12345678900.00
16227 import from TempA all;
16228 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16229 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16235 if ((enc_DER_PDU(b) == '090D033132333435363738392E4532'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);}
16239 Overall verdict: pass
16245 .*---------------------------------------------------------------------*
16246 :h3.CER + DER encoding of REAL, -12 (primitive)
16247 .*---------------------------------------------------------------------*
16250 <TC - CER + DER encoding of REAL, -12 (primitive)>
16265 import from TempA all;
16266 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16267 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16273 if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16277 Overall verdict: pass
16283 .*---------------------------------------------------------------------*
16284 :h3.CER + DER encoding of REAL, -12.0 (primitive)
16285 .*---------------------------------------------------------------------*
16288 <TC - CER + DER encoding of REAL, -12.0 (primitive)>
16303 import from TempA all;
16304 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16305 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16311 if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16315 Overall verdict: pass
16321 .*---------------------------------------------------------------------*
16322 :h3.CER + DER encoding of REAL, -12.0E0 (primitive)
16323 .*---------------------------------------------------------------------*
16326 <TC - CER + DER encoding of REAL, -12.0E0 (primitive)>
16335 b BERPDU ::= -12.0E0
16341 import from TempA all;
16342 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16343 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16349 if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16353 Overall verdict: pass
16359 .*---------------------------------------------------------------------*
16360 :h3.CER + DER encoding of REAL, -1.2E1 (primitive)
16361 .*---------------------------------------------------------------------*
16364 <TC - CER + DER encoding of REAL, -1.2E1 (primitive)>
16373 b BERPDU ::= -1.2E1
16379 import from TempA all;
16380 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16381 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16387 if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16391 Overall verdict: pass
16397 .*---------------------------------------------------------------------*
16398 :h3.CER + DER encoding of REAL, -0.12E2 (primitive)
16399 .*---------------------------------------------------------------------*
16402 <TC - CER + DER encoding of REAL, -0.12E2 (primitive)>
16411 b BERPDU ::= -0.12E2
16417 import from TempA all;
16418 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16419 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16425 if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16429 Overall verdict: pass
16435 .*---------------------------------------------------------------------*
16436 :h3.CER + DER encoding of REAL, -1.2E+1 (primitive)
16437 .*---------------------------------------------------------------------*
16440 <TC - CER + DER encoding of REAL, -1.2E+1 (primitive)>
16449 b BERPDU ::= -1.2E1
16455 import from TempA all;
16456 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16457 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16463 if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16467 Overall verdict: pass
16473 .*---------------------------------------------------------------------*
16474 :h3.CER + DER encoding of REAL, -0.12E+2 (primitive)
16475 .*---------------------------------------------------------------------*
16478 <TC - CER + DER encoding of REAL, -0.12E+2 (primitive)>
16487 b BERPDU ::= -0.12E2
16493 import from TempA all;
16494 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16495 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16501 if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16505 Overall verdict: pass
16511 .*---------------------------------------------------------------------*
16512 :h3.CER + DER encoding of REAL, -0.34 (primitive)
16513 .*---------------------------------------------------------------------*
16516 <TC - CER + DER encoding of REAL, -0.34 (primitive)>
16531 import from TempA all;
16532 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16533 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16539 if ((enc_DER_PDU(b) == '0908032D33342E452D32'O)and(enc_CER_PDU(b) == '0908032D33342E452D32'O)) {setverdict(pass);} else {setverdict(fail);}
16543 Overall verdict: pass
16549 .*---------------------------------------------------------------------*
16550 :h3.CER + DER encoding of REAL, -0.344 (primitive)
16551 .*---------------------------------------------------------------------*
16554 <TC - CER + DER encoding of REAL, -0.344 (primitive)>
16563 b BERPDU ::= -0.344
16569 import from TempA all;
16570 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16571 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16577 if ((enc_DER_PDU(b) == '0909032D3334342E452D33'O)and(enc_CER_PDU(b) == '0909032D3334342E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
16581 Overall verdict: pass
16587 .*---------------------------------------------------------------------*
16588 :h3.CER + DER encoding of REAL, -0.345 (primitive)
16589 .*---------------------------------------------------------------------*
16592 <TC - CER + DER encoding of REAL, -0.345 (primitive)>
16601 b BERPDU ::= -0.345
16607 import from TempA all;
16608 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16609 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16615 if ((enc_DER_PDU(b) == '0909032D3334352E452D33'O)and(enc_CER_PDU(b) == '0909032D3334352E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
16619 Overall verdict: pass
16625 .*---------------------------------------------------------------------*
16626 :h3.CER + DER encoding of REAL, -0.034 (primitive)
16627 .*---------------------------------------------------------------------*
16630 <TC - CER + DER encoding of REAL, -0.034 (primitive)>
16639 b BERPDU ::= -0.034
16645 import from TempA all;
16646 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16647 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16653 if ((enc_DER_PDU(b) == '0908032D33342E452D33'O)and(enc_CER_PDU(b) == '0908032D33342E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
16657 Overall verdict: pass
16663 .*---------------------------------------------------------------------*
16664 :h3.CER + DER encoding of REAL, -0.0034 (primitive)
16665 .*---------------------------------------------------------------------*
16668 <TC - CER + DER encoding of REAL, -0.0034 (primitive)>
16677 b BERPDU ::= -0.0034
16683 import from TempA all;
16684 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16685 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16691 if ((enc_DER_PDU(b) == '0908032D33342E452D34'O)and(enc_CER_PDU(b) == '0908032D33342E452D34'O)) {setverdict(pass);} else {setverdict(fail);}
16695 Overall verdict: pass
16701 .*---------------------------------------------------------------------*
16702 :h3.CER + DER encoding of REAL, -0.304 (primitive)
16703 .*---------------------------------------------------------------------*
16706 <TC - CER + DER encoding of REAL, -0.304 (primitive)>
16715 b BERPDU ::= -0.304
16721 import from TempA all;
16722 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16723 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16729 if ((enc_DER_PDU(b) == '0909032D3330342E452D33'O)and(enc_CER_PDU(b) == '0909032D3330342E452D33'O)) {setverdict(pass);} else {setverdict(fail);}
16733 Overall verdict: pass
16739 .*---------------------------------------------------------------------*
16740 :h3.CER + DER encoding of REAL, -0.1234567890 (primitive)
16741 .*---------------------------------------------------------------------*
16744 <TC - CER + DER encoding of REAL, -0.1234567890 (primitive)>
16753 b BERPDU ::= -0.1234567890
16759 import from TempA all;
16760 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16761 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16767 if ((enc_DER_PDU(b) == '090F032D3132333435363738392E452D39'O)and(enc_CER_PDU(b) == '090F032D3132333435363738392E452D39'O)) {setverdict(pass);} else {setverdict(fail);}
16771 Overall verdict: pass
16777 .*---------------------------------------------------------------------*
16778 :h3.CER + DER encoding of REAL, -0.123456789 (primitive)
16779 .*---------------------------------------------------------------------*
16782 <TC - CER + DER encoding of REAL, -0.123456789 (primitive)>
16791 b BERPDU ::= -0.123456789
16797 import from TempA all;
16798 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16799 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16805 if ((enc_DER_PDU(b) == '090F032D3132333435363738392E452D39'O)and(enc_CER_PDU(b) == '090F032D3132333435363738392E452D39'O)) {setverdict(pass);} else {setverdict(fail);}
16809 Overall verdict: pass
16815 .*---------------------------------------------------------------------*
16816 :h3.CER + DER encoding of REAL, -0.0123456789 (primitive)
16817 .*---------------------------------------------------------------------*
16820 <TC - CER + DER encoding of REAL, -0.0123456789 (primitive)>
16829 b BERPDU ::= -0.0123456789
16835 import from TempA all;
16836 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16837 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16843 if ((enc_DER_PDU(b) == '0910032D3132333435363738392E452D3130'O)and(enc_CER_PDU(b) == '0910032D3132333435363738392E452D3130'O)) {setverdict(pass);} else {setverdict(fail);}
16847 Overall verdict: pass
16853 .*---------------------------------------------------------------------*
16854 :h3.CER + DER encoding of REAL, -123456789.0 (primitive)
16855 .*---------------------------------------------------------------------*
16858 <TC - CER + DER encoding of REAL, -123456789.0 (primitive)>
16867 b BERPDU ::= -123456789.0
16873 import from TempA all;
16874 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16875 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16881 if ((enc_DER_PDU(b) == '090F032D3132333435363738392E452B30'O)and(enc_CER_PDU(b) == '090F032D3132333435363738392E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16885 Overall verdict: pass
16891 .*---------------------------------------------------------------------*
16892 :h3.CER + DER encoding of REAL, -123456789 (primitive)
16893 .*---------------------------------------------------------------------*
16896 <TC - CER + DER encoding of REAL, -123456789 (primitive)>
16905 b BERPDU ::= -123456789
16911 import from TempA all;
16912 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16913 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16919 if ((enc_DER_PDU(b) == '090F032D3132333435363738392E452B30'O)and(enc_CER_PDU(b) == '090F032D3132333435363738392E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
16923 Overall verdict: pass
16929 .*---------------------------------------------------------------------*
16930 :h3.CER + DER encoding of REAL, -1234567890 (primitive)
16931 .*---------------------------------------------------------------------*
16934 <TC - CER + DER encoding of REAL, -1234567890 (primitive)>
16943 b BERPDU ::= -1234567890
16949 import from TempA all;
16950 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16951 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16957 if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4531'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);}
16961 Overall verdict: pass
16967 .*---------------------------------------------------------------------*
16968 :h3.CER + DER encoding of REAL, -1234567890.0 (primitive)
16969 .*---------------------------------------------------------------------*
16972 <TC - CER + DER encoding of REAL, -1234567890.0 (primitive)>
16981 b BERPDU ::= -1234567890.0
16987 import from TempA all;
16988 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
16989 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
16995 if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4531'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);}
16999 Overall verdict: pass
17005 .*---------------------------------------------------------------------*
17006 :h3.CER + DER encoding of REAL, -1234567890.00 (primitive)
17007 .*---------------------------------------------------------------------*
17010 <TC - CER + DER encoding of REAL, -1234567890.00 (primitive)>
17019 b BERPDU ::= -1234567890.00
17025 import from TempA all;
17026 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17027 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17033 if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4531'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);}
17037 Overall verdict: pass
17043 .*---------------------------------------------------------------------*
17044 :h3.CER + DER encoding of REAL, -12345678900.0 (primitive)
17045 .*---------------------------------------------------------------------*
17048 <TC - CER + DER encoding of REAL, -12345678900.0 (primitive)>
17057 b BERPDU ::= -12345678900.0
17063 import from TempA all;
17064 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17065 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17071 if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4532'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);}
17075 Overall verdict: pass
17081 .*---------------------------------------------------------------------*
17082 :h3.CER + DER encoding of REAL, -12345678900.0 (primitive)
17083 .*---------------------------------------------------------------------*
17086 <TC - CER + DER encoding of REAL, -12345678900.0 (primitive)>
17095 b BERPDU ::= -12345678900.0
17101 import from TempA all;
17102 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17103 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17109 if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4532'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);}
17113 Overall verdict: pass
17119 .*---------------------------------------------------------------------*
17120 :h3.CER + DER encoding of REAL, -12345678900.00 (primitive)
17121 .*---------------------------------------------------------------------*
17124 <TC - CER + DER encoding of REAL, -12345678900.00 (primitive)>
17133 b BERPDU ::= -12345678900.00
17139 import from TempA all;
17140 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17141 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17147 if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4532'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);}
17151 Overall verdict: pass
17157 .*---------------------------------------------------------------------*
17158 :h3.CER + DER encoding of REAL, PLUS-INFINITY (primitive)
17159 .*---------------------------------------------------------------------*
17162 <TC - CER + DER encoding of REAL, PLUS-INFINITY (primitive)>
17171 b BERPDU ::= PLUS-INFINITY
17177 import from TempA all;
17178 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17179 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17185 if ((enc_DER_PDU(b) == '090140'O)and(enc_CER_PDU(b) == '090140'O)) {setverdict(pass);} else {setverdict(fail);}
17189 Overall verdict: pass
17195 .*---------------------------------------------------------------------*
17196 :h3.CER + DER encoding of REAL, MINUS-INFINITY (primitive)
17197 .*---------------------------------------------------------------------*
17200 <TC - CER + DER encoding of REAL, MINUS-INFINITY (primitive)>
17209 b BERPDU ::= MINUS-INFINITY
17215 import from TempA all;
17216 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17217 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17223 if ((enc_DER_PDU(b) == '090141'O)and(enc_CER_PDU(b) == '090141'O)) {setverdict(pass);} else {setverdict(fail);}
17227 Overall verdict: pass
17233 .*---------------------------------------------------------------------*
17234 :h3.CER + DER encoding of REAL, 1 , IMPICIT TAG
17235 .*---------------------------------------------------------------------*
17238 <TC - CER + DER encoding of REAL, 1 , IMPICIT TAG>
17246 BERPDU ::= [0] IMPLICIT REAL
17253 import from TempA all;
17254 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17255 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17261 if ((enc_DER_PDU(b) == '800603312E452B30'O)and(enc_CER_PDU(b) == '800603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
17265 Overall verdict: pass
17271 .*---------------------------------------------------------------------*
17272 :h3.CER + DER encoding of REAL, 1 , EXPICIT TAG
17273 .*---------------------------------------------------------------------*
17276 <TC - CER + DER encoding of REAL, 1 , EXPICIT TAG>
17284 BERPDU ::= [0] EXPLICIT REAL
17291 import from TempA all;
17292 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17293 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17299 if ((enc_DER_PDU(b) == 'A008090603312E452B30'O)and(enc_CER_PDU(b) == 'A080090603312E452B300000'O)) {setverdict(pass);} else {setverdict(fail);}
17303 Overall verdict: pass
17309 .*---------------------------------------------------------------------*
17310 :h3.CER + DER encoding of BIT STRING, length = 0 (primitive)
17311 .*---------------------------------------------------------------------*
17314 <TC - CER + DER encoding of BIT STRING, length = 0 (primitive)>
17322 BERPDU ::= BIT STRING
17327 import from TempA all;
17328 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17329 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17331 const BERPDU b := ''B
17335 if ((enc_DER_PDU(b) == '030100'O)and(enc_CER_PDU(b) == '030100'O)) {setverdict(pass);} else {setverdict(fail);}
17339 Overall verdict: pass
17345 .*---------------------------------------------------------------------*
17346 :h3.CER + DER encoding of BIT STRING, length = 1 (primitive)
17347 .*---------------------------------------------------------------------*
17350 <TC - CER + DER encoding of BIT STRING, length = 1 (primitive)>
17358 BERPDU ::= BIT STRING
17363 import from TempA all;
17364 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17365 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17367 const BERPDU b := '1'B
17371 if ((enc_DER_PDU(b) == '03020780'O)and(enc_CER_PDU(b) == '03020780'O)) {setverdict(pass);} else {setverdict(fail);}
17375 Overall verdict: pass
17381 .*---------------------------------------------------------------------*
17382 :h3.CER + DER encoding of BIT STRING, length = 7 (primitive)
17383 .*---------------------------------------------------------------------*
17386 <TC - CER + DER encoding of BIT STRING, length = 7 (primitive)>
17394 BERPDU ::= BIT STRING
17399 import from TempA all;
17400 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17401 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17403 const BERPDU b := '1010101'B
17406 if ((enc_DER_PDU(b) == '030201AA'O)and(enc_CER_PDU(b) == '030201AA'O)) {setverdict(pass);} else {setverdict(fail);}
17410 Overall verdict: pass
17416 .*---------------------------------------------------------------------*
17417 :h3.CER + DER encoding of BIT STRING, length = 8 (primitive)
17418 .*---------------------------------------------------------------------*
17421 <TC - CER + DER encoding of BIT STRING, length = 8 (primitive)>
17429 BERPDU ::= BIT STRING
17434 import from TempA all;
17435 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17436 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17438 const BERPDU b := '10101010'B
17441 if ((enc_DER_PDU(b) == '030200AA'O)and(enc_CER_PDU(b) == '030200AA'O)) {setverdict(pass);} else {setverdict(fail);}
17445 Overall verdict: pass
17451 .*---------------------------------------------------------------------*
17452 :h3.CER + DER encoding of BIT STRING, length = 9 (primitive)
17453 .*---------------------------------------------------------------------*
17456 <TC - CER + DER encoding of BIT STRING, length = 9 (primitive)>
17464 BERPDU ::= BIT STRING
17469 import from TempA all;
17470 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17471 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17473 const BERPDU b := '111100001'B
17477 if ((enc_DER_PDU(b) == '030307F080'O)and(enc_CER_PDU(b) == '030307F080'O)) {setverdict(pass);} else {setverdict(fail);}
17481 Overall verdict: pass
17487 .*---------------------------------------------------------------------*
17488 :h3.CER(primitive) + DER(primitive) encoding of BIT STRING, contents length = 1000 octets (999 octets of data and one unused bits octet)
17489 .*---------------------------------------------------------------------*
17492 <TC - CER(primitive) + DER(primitive) encoding of BIT STRING, contents length = 1000 octets (999 octets of data and one unused bits octet)>
17500 BERPDU ::= BIT STRING
17502 b BERPDU ::= 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
17510 import from TempA all;
17511 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17512 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17516 if ((enc_DER_PDU(b) == '038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)and(enc_CER_PDU(b) == '038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)) {setverdict(pass);} else {setverdict(fail);}
17520 Overall verdict: pass
17526 .*---------------------------------------------------------------------*
17527 :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
17528 .*---------------------------------------------------------------------*
17531 <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>
17539 BERPDU ::= BIT STRING
17541 b BERPDU ::= 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
17548 import from TempA all;
17549 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17550 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17555 if ((enc_DER_PDU(b) == '038203E900FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)and(enc_CER_PDU(b)
17556 == '2380038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF030200FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
17560 Overall verdict: pass
17566 .*---------------------------------------------------------------------*
17567 :h3.CER + DER encoding of BIT STRING, length = 1, IMPLICIT TAG (primitive)
17568 .*---------------------------------------------------------------------*
17571 <TC - CER + DER encoding of BIT STRING, length = 1, IMPLICIT TAG (primitive)>
17579 BERPDU ::= [0] IMPLICIT BIT STRING
17584 import from TempA all;
17585 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17586 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17588 const BERPDU b := '1'B
17592 if ((enc_DER_PDU(b) == '80020780'O)and(enc_CER_PDU(b) == '80020780'O)) {setverdict(pass);} else {setverdict(fail);}
17596 Overall verdict: pass
17602 .*---------------------------------------------------------------------*
17603 :h3.CER + DER encoding of BIT STRING, length = 1, EXPLICIT TAG (constructed)
17604 .*---------------------------------------------------------------------*
17607 <TC - CER + DER encoding of BIT STRING, length = 1, EXPLICIT TAG (constructed)>
17615 BERPDU ::= [0] EXPLICIT BIT STRING
17620 import from TempA all;
17621 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
17622 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
17624 const BERPDU b := '1'B
17628 if ((enc_DER_PDU(b) == 'A00403020780'O)and(enc_CER_PDU(b) == 'A080030207800000'O)) {setverdict(pass);} else {setverdict(fail);}
17632 Overall verdict: pass
17638 .*---------------------------------------------------------------------*
17639 :h3. DECODING BIT STRING ,length = 0 ,CER +DER (primitive)
17640 .*---------------------------------------------------------------------*
17643 <TC - DECODING BIT STRING ,length = 0 ,CER +DER (primitive)>
17651 BERPDU ::= BIT STRING
17653 myValue BERPDU ::=''B
17659 import from TempA all;
17661 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17666 if (dec_BER_PDU('030100'O) == myValue)
17669 {setverdict(pass);} else {setverdict(fail);}
17674 Overall verdict: pass
17680 .*---------------------------------------------------------------------*
17681 :h3. DECODING BIT STRING ,length = 0 ,constructed
17682 .*---------------------------------------------------------------------*
17685 <TC - DECODING BIT STRING ,length = 0 ,constructed>
17693 BERPDU ::= BIT STRING
17695 myValue BERPDU ::=''B
17701 import from TempA all;
17703 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17708 if (dec_BER_PDU('2303030100'O) == myValue)
17711 {setverdict(pass);} else {setverdict(fail);}
17716 Overall verdict: pass
17722 .*---------------------------------------------------------------------*
17723 :h3. DECODING BIT STRING ,2xlength = 0 ,constructed
17724 .*---------------------------------------------------------------------*
17727 <TC - DECODING BIT STRING ,2xlength = 0 ,constructed>
17735 BERPDU ::= BIT STRING
17737 myValue BERPDU ::=''B
17743 import from TempA all;
17745 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17750 if (dec_BER_PDU('2306030100030100'O) == myValue)
17753 {setverdict(pass);} else {setverdict(fail);}
17758 Overall verdict: pass
17764 .*---------------------------------------------------------------------*
17765 :h3. DECODING BIT STRING ,length = 0 ,constructed, indefinite
17766 .*---------------------------------------------------------------------*
17769 <TC - DECODING BIT STRING ,length = 0 ,constructed, indefinite>
17777 BERPDU ::= BIT STRING
17779 myIntegerValue BERPDU ::=''B
17785 import from TempA all;
17787 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17792 if (dec_BER_PDU('23800301000000'O) == myIntegerValue)
17795 {setverdict(pass);} else {setverdict(fail);}
17800 Overall verdict: pass
17806 .*---------------------------------------------------------------------*
17807 :h3. DECODING BIT STRING ,length = 1 ,CER + DER, (primitive)
17808 .*---------------------------------------------------------------------*
17811 <TC - DECODING BIT STRING ,length = 1 ,CER + DER, (primitive)>
17819 BERPDU ::= BIT STRING
17821 myValue BERPDU ::='1'B
17827 import from TempA all;
17829 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17834 if (dec_BER_PDU('03020780'O) == myValue)
17837 {setverdict(pass);} else {setverdict(fail);}
17842 Overall verdict: pass
17848 .*---------------------------------------------------------------------*
17849 :h3. DECODING BIT STRING ,length = 1 , (primitive, long form)
17850 .*---------------------------------------------------------------------*
17853 <TC - DECODING BIT STRING ,length = 1 , (primitive, long form)>
17861 BERPDU ::= BIT STRING
17863 myIntegerValue BERPDU ::='1'B
17869 import from TempA all;
17871 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17876 if (dec_BER_PDU('0381020780'O) == myIntegerValue)
17879 {setverdict(pass);} else {setverdict(fail);}
17884 Overall verdict: pass
17890 .*---------------------------------------------------------------------*
17891 :h3. DECODING BIT STRING ,length = 1 , (constructed, short form - short form)
17892 .*---------------------------------------------------------------------*
17895 <TC - DECODING BIT STRING ,length = 1 , (constructed, short form - short form)>
17903 BERPDU ::= BIT STRING
17905 myValue BERPDU ::='1'B
17911 import from TempA all;
17913 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17918 if (dec_BER_PDU('230403020780'O) == myValue)
17921 {setverdict(pass);} else {setverdict(fail);}
17926 Overall verdict: pass
17932 .*---------------------------------------------------------------------*
17933 :h3. DECODING BIT STRING ,length = 1 , (constructed, short form - long form)
17934 .*---------------------------------------------------------------------*
17937 <TC - DECODING BIT STRING ,length = 1 , (constructed, short form - long form)>
17945 BERPDU ::= BIT STRING
17947 myValue BERPDU ::='1'B
17953 import from TempA all;
17955 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
17960 if (dec_BER_PDU('23050381020780'O) == myValue)
17963 {setverdict(pass);} else {setverdict(fail);}
17968 Overall verdict: pass
17974 .*---------------------------------------------------------------------*
17975 :h3. DECODING BIT STRING ,length = 1 , (constructed, long form - long form)
17976 .*---------------------------------------------------------------------*
17979 <TC - DECODING BIT STRING ,length = 1 , (constructed, long form - long form)>
17987 BERPDU ::= BIT STRING
17989 myValue BERPDU ::='1'B
17995 import from TempA all;
17997 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18002 if (dec_BER_PDU('2381050381020780'O) == myValue)
18005 {setverdict(pass);} else {setverdict(fail);}
18010 Overall verdict: pass
18016 .*---------------------------------------------------------------------*
18017 :h3. DECODING BIT STRING ,length = 1 , (constructed, indefinite form)
18018 .*---------------------------------------------------------------------*
18021 <TC - DECODING BIT STRING ,length = 1 , (constructed, indefinite form)>
18029 BERPDU ::= BIT STRING
18031 myValue BERPDU ::='1'B
18037 import from TempA all;
18039 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18044 if (dec_BER_PDU('238003810207800000'O) == myValue)
18047 {setverdict(pass);} else {setverdict(fail);}
18052 Overall verdict: pass
18058 .*---------------------------------------------------------------------*
18059 :h3. DECODING BIT STRING ,2xlength = 1 , (constructed, short form - short form)
18060 .*---------------------------------------------------------------------*
18063 <TC - DECODING BIT STRING ,2xlength = 1 , (constructed, short form - short form)>
18071 BERPDU ::= BIT STRING
18073 myValue BERPDU ::='11'B
18079 import from TempA all;
18081 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER:BER_ACCEPT_ALL)" }
18086 if (dec_BER_PDU('23080302078003020780'O) == myValue)
18089 {setverdict(pass);} else {setverdict(fail);}
18094 Overall verdict: pass
18100 .*---------------------------------------------------------------------*
18101 :h3. DECODING BIT STRING ,2xlength = 1 , (constructed inside constructed)
18102 .*---------------------------------------------------------------------*
18105 <TC - DECODING BIT STRING ,2xlength = 1 , (constructed inside constructed)>
18113 BERPDU ::= BIT STRING
18115 myValue BERPDU ::='1'B
18121 import from TempA all;
18123 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18128 if (dec_BER_PDU('2306230403020780'O) == myValue)
18131 {setverdict(pass);} else {setverdict(fail);}
18136 Overall verdict: pass
18142 .*---------------------------------------------------------------------*
18143 :h3. DECODING BIT STRING ,length = 7 ,CER + DER, (primitive)
18144 .*---------------------------------------------------------------------*
18147 <TC - DECODING BIT STRING ,length = 7 ,CER + DER, (primitive)>
18155 BERPDU ::= BIT STRING
18157 myValue BERPDU ::='1010101'B
18163 import from TempA all;
18165 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18170 if (dec_BER_PDU('030201AA'O) == myValue)
18173 {setverdict(pass);} else {setverdict(fail);}
18178 Overall verdict: pass
18184 .*---------------------------------------------------------------------*
18185 :h3. DECODING BIT STRING ,length = 7 , (primitive, long form)
18186 .*---------------------------------------------------------------------*
18189 <TC - DECODING BIT STRING ,length = 7 , (primitive, long form)>
18197 BERPDU ::= BIT STRING
18199 myIntegerValue BERPDU ::='1010101'B
18205 import from TempA all;
18207 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18212 if (dec_BER_PDU('03810201AA'O) == myIntegerValue)
18215 {setverdict(pass);} else {setverdict(fail);}
18220 Overall verdict: pass
18226 .*---------------------------------------------------------------------*
18227 :h3. DECODING BIT STRING ,length = 7 , (constructed, short form - short form)
18228 .*---------------------------------------------------------------------*
18231 <TC - DECODING BIT STRING ,length = 7 , (constructed, short form - short form)>
18239 BERPDU ::= BIT STRING
18241 myValue BERPDU ::='1010101'B
18247 import from TempA all;
18249 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18254 if (dec_BER_PDU('2304030201AA'O) == myValue)
18257 {setverdict(pass);} else {setverdict(fail);}
18262 Overall verdict: pass
18268 .*---------------------------------------------------------------------*
18269 :h3. DECODING BIT STRING ,length = 7 , (constructed, short form - long form)
18270 .*---------------------------------------------------------------------*
18273 <TC - DECODING BIT STRING ,length = 7 , (constructed, short form - long form)>
18281 BERPDU ::= BIT STRING
18283 myValue BERPDU ::='1010101'B
18289 import from TempA all;
18291 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18296 if (dec_BER_PDU('230503810201AA'O) == myValue)
18299 {setverdict(pass);} else {setverdict(fail);}
18304 Overall verdict: pass
18310 .*---------------------------------------------------------------------*
18311 :h3. DECODING BIT STRING ,length = 7 , (constructed, long form - long form)
18312 .*---------------------------------------------------------------------*
18315 <TC - DECODING BIT STRING ,length = 7 , (constructed, long form - long form)>
18323 BERPDU ::= BIT STRING
18325 myValue BERPDU ::='1010101'B
18331 import from TempA all;
18333 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18338 if (dec_BER_PDU('23810503810201AA'O) == myValue)
18341 {setverdict(pass);} else {setverdict(fail);}
18346 Overall verdict: pass
18352 .*---------------------------------------------------------------------*
18353 :h3. DECODING BIT STRING ,length = 7 , (constructed, indefinite form)
18354 .*---------------------------------------------------------------------*
18357 <TC - DECODING BIT STRING ,length = 7 , (constructed, indefinite form)>
18365 BERPDU ::= BIT STRING
18367 myValue BERPDU ::='1010101'B
18373 import from TempA all;
18375 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18380 if (dec_BER_PDU('238003810201AA0000'O) == myValue)
18383 {setverdict(pass);} else {setverdict(fail);}
18388 Overall verdict: pass
18394 .*---------------------------------------------------------------------*
18395 :h3. DECODING BIT STRING ,2xlength = 7 , (constructed, short form - short form)
18396 .*---------------------------------------------------------------------*
18399 <TC - DECODING BIT STRING ,2xlength = 7 , (constructed, short form - short form)>
18407 BERPDU ::= BIT STRING
18409 myValue BERPDU ::='10101011010101'B
18415 import from TempA all;
18417 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18422 if (dec_BER_PDU('2308030201AA030201AA'O) == myValue)
18425 {setverdict(pass);} else {setverdict(fail);}
18430 Overall verdict: pass
18436 .*---------------------------------------------------------------------*
18437 :h3. DECODING BIT STRING ,2xlength = 7 , (constructed inside constructed)
18438 .*---------------------------------------------------------------------*
18441 <TC - DECODING BIT STRING ,2xlength = 7 , (constructed inside constructed)>
18449 BERPDU ::= BIT STRING
18451 myValue BERPDU ::='1010101'B
18457 import from TempA all;
18459 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18464 if (dec_BER_PDU('23062304030201AA'O) == myValue)
18467 {setverdict(pass);} else {setverdict(fail);}
18472 Overall verdict: pass
18478 .*---------------------------------------------------------------------*
18479 :h3. DECODING BIT STRING ,length = 8 ,CER + DER, (primitive)
18480 .*---------------------------------------------------------------------*
18483 <TC - DECODING BIT STRING ,length = 8 ,CER + DER, (primitive)>
18491 BERPDU ::= BIT STRING
18493 myValue BERPDU ::='10101010'B
18499 import from TempA all;
18501 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18506 if (dec_BER_PDU('030200AA'O) == myValue)
18509 {setverdict(pass);} else {setverdict(fail);}
18514 Overall verdict: pass
18520 .*---------------------------------------------------------------------*
18521 :h3. DECODING BIT STRING ,length = 8 , (primitive, long form)
18522 .*---------------------------------------------------------------------*
18525 <TC - DECODING BIT STRING ,length = 8 , (primitive, long form)>
18533 BERPDU ::= BIT STRING
18535 myIntegerValue BERPDU ::='10101010'B
18541 import from TempA all;
18543 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18548 if (dec_BER_PDU('03810200AA'O) == myIntegerValue)
18551 {setverdict(pass);} else {setverdict(fail);}
18556 Overall verdict: pass
18562 .*---------------------------------------------------------------------*
18563 :h3. DECODING BIT STRING ,length = 8 , (constructed, short form - short form)
18564 .*---------------------------------------------------------------------*
18567 <TC - DECODING BIT STRING ,length = 8 , (constructed, short form - short form)>
18575 BERPDU ::= BIT STRING
18577 myValue BERPDU ::='10101010'B
18583 import from TempA all;
18585 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18590 if (dec_BER_PDU('2304030200AA'O) == myValue)
18593 {setverdict(pass);} else {setverdict(fail);}
18598 Overall verdict: pass
18604 .*---------------------------------------------------------------------*
18605 :h3. DECODING BIT STRING ,length = 8 , (constructed, short form - long form)
18606 .*---------------------------------------------------------------------*
18609 <TC - DECODING BIT STRING ,length = 8 , (constructed, short form - long form)>
18617 BERPDU ::= BIT STRING
18619 myValue BERPDU ::='10101010'B
18625 import from TempA all;
18627 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18632 if (dec_BER_PDU('230503810200AA'O) == myValue)
18635 {setverdict(pass);} else {setverdict(fail);}
18640 Overall verdict: pass
18646 .*---------------------------------------------------------------------*
18647 :h3. DECODING BIT STRING ,length = 8 , (constructed, long form - long form)
18648 .*---------------------------------------------------------------------*
18651 <TC - DECODING BIT STRING ,length = 8 , (constructed, long form - long form)>
18659 BERPDU ::= BIT STRING
18661 myValue BERPDU ::='10101010'B
18667 import from TempA all;
18669 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18674 if (dec_BER_PDU('23810503810200AA'O) == myValue)
18677 {setverdict(pass);} else {setverdict(fail);}
18682 Overall verdict: pass
18688 .*---------------------------------------------------------------------*
18689 :h3. DECODING BIT STRING ,length = 8 , (constructed, indefinite form)
18690 .*---------------------------------------------------------------------*
18693 <TC - DECODING BIT STRING ,length = 8 , (constructed, indefinite form)>
18701 BERPDU ::= BIT STRING
18703 myValue BERPDU ::='10101010'B
18709 import from TempA all;
18711 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18716 if (dec_BER_PDU('238003810200AA0000'O) == myValue)
18719 {setverdict(pass);} else {setverdict(fail);}
18724 Overall verdict: pass
18730 .*---------------------------------------------------------------------*
18731 :h3. DECODING BIT STRING ,2xlength = 8 , (constructed, short form - short form)
18732 .*---------------------------------------------------------------------*
18735 <TC - DECODING BIT STRING ,2xlength = 8 , (constructed, short form - short form)>
18743 BERPDU ::= BIT STRING
18745 myValue BERPDU ::='1010101010101010'B
18751 import from TempA all;
18753 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18758 if (dec_BER_PDU('2308030200AA030200AA'O) == myValue)
18761 {setverdict(pass);} else {setverdict(fail);}
18766 Overall verdict: pass
18772 .*---------------------------------------------------------------------*
18773 :h3. DECODING BIT STRING ,2xlength = 8 , (constructed inside constructed)
18774 .*---------------------------------------------------------------------*
18777 <TC - DECODING BIT STRING ,2xlength = 8 , (constructed inside constructed)>
18785 BERPDU ::= BIT STRING
18787 myValue BERPDU ::='10101010'B
18793 import from TempA all;
18795 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18800 if (dec_BER_PDU('23062304030200AA'O) == myValue)
18803 {setverdict(pass);} else {setverdict(fail);}
18808 Overall verdict: pass
18814 .*---------------------------------------------------------------------*
18815 :h3. DECODING BIT STRING ,length = 9 ,CER + DER, (primitive)
18816 .*---------------------------------------------------------------------*
18819 <TC - DECODING BIT STRING ,length = 9 ,CER + DER, (primitive)>
18827 BERPDU ::= BIT STRING
18829 myValue BERPDU ::='111100001'B
18835 import from TempA all;
18837 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18842 if (dec_BER_PDU( '030307F080'O) == myValue)
18845 {setverdict(pass);} else {setverdict(fail);}
18850 Overall verdict: pass
18856 .*---------------------------------------------------------------------*
18857 :h3. DECODING BIT STRING ,length = 9 , (primitive, long form)
18858 .*---------------------------------------------------------------------*
18861 <TC - DECODING BIT STRING ,length = 9 , (primitive, long form)>
18869 BERPDU ::= BIT STRING
18871 myIntegerValue BERPDU ::='111100001'B
18877 import from TempA all;
18879 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18884 if (dec_BER_PDU('03810307F080'O) == myIntegerValue)
18887 {setverdict(pass);} else {setverdict(fail);}
18892 Overall verdict: pass
18898 .*---------------------------------------------------------------------*
18899 :h3. DECODING BIT STRING ,length = 9 , (constructed, short form - short form)
18900 .*---------------------------------------------------------------------*
18903 <TC - DECODING BIT STRING ,length = 9 , (constructed, short form - short form)>
18911 BERPDU ::= BIT STRING
18913 myValue BERPDU ::='111100001'B
18919 import from TempA all;
18921 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18926 if (dec_BER_PDU('2305030307F080'O) == myValue)
18929 {setverdict(pass);} else {setverdict(fail);}
18934 Overall verdict: pass
18940 .*---------------------------------------------------------------------*
18941 :h3. DECODING BIT STRING ,length = 9 , (constructed, short form - long form)
18942 .*---------------------------------------------------------------------*
18945 <TC - DECODING BIT STRING ,length = 9 , (constructed, short form - long form)>
18953 BERPDU ::= BIT STRING
18955 myValue BERPDU ::='111100001'B
18961 import from TempA all;
18963 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
18968 if (dec_BER_PDU('230603810307F080'O) == myValue)
18971 {setverdict(pass);} else {setverdict(fail);}
18976 Overall verdict: pass
18982 .*---------------------------------------------------------------------*
18983 :h3. DECODING BIT STRING ,length = 9 , (constructed, long form - long form)
18984 .*---------------------------------------------------------------------*
18987 <TC - DECODING BIT STRING ,length = 9 , (constructed, long form - long form)>
18995 BERPDU ::= BIT STRING
18997 myValue BERPDU ::='111100001'B
19003 import from TempA all;
19005 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19010 if (dec_BER_PDU('23810603810307F080'O) == myValue)
19013 {setverdict(pass);} else {setverdict(fail);}
19018 Overall verdict: pass
19024 .*---------------------------------------------------------------------*
19025 :h3. DECODING BIT STRING ,length = 9 , (constructed, indefinite form)
19026 .*---------------------------------------------------------------------*
19029 <TC - DECODING BIT STRING ,length = 9 , (constructed, indefinite form)>
19037 BERPDU ::= BIT STRING
19039 myValue BERPDU ::='111100001'B
19045 import from TempA all;
19047 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19052 if (dec_BER_PDU('238003810307F0800000'O) == myValue)
19055 {setverdict(pass);} else {setverdict(fail);}
19060 Overall verdict: pass
19066 .*---------------------------------------------------------------------*
19067 :h3. DECODING BIT STRING ,2xlength = 9 , (constructed, short form - short form)
19068 .*---------------------------------------------------------------------*
19071 <TC - DECODING BIT STRING ,2xlength = 9 , (constructed, short form - short form)>
19079 BERPDU ::= BIT STRING
19081 myValue BERPDU ::='111100001111100001'B
19087 import from TempA all;
19089 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19094 if (dec_BER_PDU('230A030307F080030307F080'O) == myValue)
19097 {setverdict(pass);} else {setverdict(fail);}
19102 Overall verdict: pass
19108 .*---------------------------------------------------------------------*
19109 :h3. DECODING BIT STRING ,length = 9 , (constructed inside constructed)
19110 .*---------------------------------------------------------------------*
19113 <TC - DECODING BIT STRING ,length = 9 , (constructed inside constructed)>
19121 BERPDU ::= BIT STRING
19123 myValue BERPDU ::='111100001'B
19129 import from TempA all;
19131 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19136 if (dec_BER_PDU('23072305030307F080'O) == myValue)
19139 {setverdict(pass);} else {setverdict(fail);}
19144 Overall verdict: pass
19150 .*---------------------------------------------------------------------*
19151 :h3. DECODING BIT STRING ,length = 1000 CER + DER, primitive (999 octets of data and one unused bits octet)
19152 .*---------------------------------------------------------------------*
19155 <TC - DECODING BIT STRING ,length = 1000 CER + DER, primitive (999 octets of data and one unused bits octet)>
19163 BERPDU ::= BIT STRING
19165 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19171 import from TempA all;
19173 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19178 if (dec_BER_PDU('038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue)
19181 {setverdict(pass);} else {setverdict(fail);}
19186 Overall verdict: pass
19192 .*---------------------------------------------------------------------*
19193 :h3. DECODING BIT STRING ,length = 1000 , primitive longer form (999 octets of data and one unused bits octet)
19194 .*---------------------------------------------------------------------*
19197 <TC - DECODING BIT STRING ,length = 1000 , primitive longer form (999 octets of data and one unused bits octet)>
19205 BERPDU ::= BIT STRING
19207 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19213 import from TempA all;
19215 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19220 if (dec_BER_PDU('03830003E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue)
19223 {setverdict(pass);} else {setverdict(fail);}
19228 Overall verdict: pass
19234 .*---------------------------------------------------------------------*
19235 :h3. DECODING BIT STRING ,length = 1000 , constructed long form -long form (999 octets of data and one unused bits octet)
19236 .*---------------------------------------------------------------------*
19239 <TC - DECODING BIT STRING ,length = 1000 , constructed long form -long form (999 octets of data and one unused bits octet)>
19247 BERPDU ::= BIT STRING
19249 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19255 import from TempA all;
19257 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19262 if (dec_BER_PDU('238203EC038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue)
19265 {setverdict(pass);} else {setverdict(fail);}
19270 Overall verdict: pass
19276 .*---------------------------------------------------------------------*
19277 :h3. DECODING BIT STRING ,length = 1000 , constructed indefinite form (999 octets of data and one unused bits octet)
19278 .*---------------------------------------------------------------------*
19281 <TC - DECODING BIT STRING ,length = 1000 , constructed indefinite form (999 octets of data and one unused bits octet)>
19289 BERPDU ::= BIT STRING
19291 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19297 import from TempA all;
19299 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19304 if (dec_BER_PDU('2380038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000'O) == myValue)
19307 {setverdict(pass);} else {setverdict(fail);}
19312 Overall verdict: pass
19318 .*---------------------------------------------------------------------*
19319 :h3. DECODING BIT STRING ,2xlength = 1000 , constructed (999 octets of data and one unused bits octet)
19320 .*---------------------------------------------------------------------*
19323 <TC - DECODING BIT STRING ,2xlength = 1000 , constructed (999 octets of data and one unused bits octet)>
19331 BERPDU ::= BIT STRING
19333 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19339 import from TempA all;
19341 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19346 if (dec_BER_PDU('238207D8038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue)
19349 {setverdict(pass);} else {setverdict(fail);}
19354 Overall verdict: pass
19360 .*---------------------------------------------------------------------*
19361 :h3. DECODING BIT STRING ,length = 1001 DER , primitive (1000 octets of data and one unused bits octet)
19362 .*---------------------------------------------------------------------*
19365 <TC - DECODING BIT STRING ,length = 1001 DER , primitive (1000 octets of data and one unused bits octet)>
19373 BERPDU ::= BIT STRING
19375 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19381 import from TempA all;
19383 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19388 if (dec_BER_PDU('038203E900FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue)
19391 {setverdict(pass);} else {setverdict(fail);}
19396 Overall verdict: pass
19402 .*---------------------------------------------------------------------*
19403 :h3. DECODING BIT STRING ,length = 1001 CER , constructed (1000 octets of data and one unused bits octet)
19404 .*---------------------------------------------------------------------*
19407 <TC - DECODING BIT STRING ,length = 1001 CER , constructed (1000 octets of data and one unused bits octet)>
19415 BERPDU ::= BIT STRING
19417 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19423 import from TempA all;
19425 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19430 if (dec_BER_PDU('238203F0038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF030200FF'O) == myValue)
19433 {setverdict(pass);} else {setverdict(fail);}
19438 Overall verdict: pass
19444 .*---------------------------------------------------------------------*
19445 :h3. DECODING BIT STRING ,length = 1001 , constructed (1000 octets of data and one unused bits octet)
19446 .*---------------------------------------------------------------------*
19449 <TC - DECODING BIT STRING ,length = 1001 , constructed (1000 octets of data and one unused bits octet)>
19457 BERPDU ::= BIT STRING
19459 myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
19465 import from TempA all;
19467 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19472 if (dec_BER_PDU('238203ED038203E900FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue)
19475 {setverdict(pass);} else {setverdict(fail);}
19480 Overall verdict: pass
19486 .*---------------------------------------------------------------------*
19487 :h3. DECODING BIT STRING CER +DER ,length = 1 , IMPLICIT TAG primitive
19488 .*---------------------------------------------------------------------*
19491 <TC - DECODING BIT STRING CER +DER ,length = 1 , IMPLICIT TAG primitive >
19499 BERPDU ::= [0] IMPLICIT BIT STRING
19501 myValue BERPDU ::='1'B
19507 import from TempA all;
19509 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19514 if (dec_BER_PDU('80020780'O) == myValue)
19517 {setverdict(pass);} else {setverdict(fail);}
19522 Overall verdict: pass
19528 .*---------------------------------------------------------------------*
19529 :h3. DECODING BIT STRING CER ,length = 1 , EXPLICIT TAG (constructed )
19530 .*---------------------------------------------------------------------*
19533 <TC - DECODING BIT STRING CER ,length = 1 , EXPLICIT TAG (constructed )>
19541 BERPDU ::= BIT STRING
19543 myValue BERPDU ::='1'B
19549 import from TempA all;
19551 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19556 if (dec_BER_PDU('A080030207800000'O) == myValue)
19559 {setverdict(pass);} else {setverdict(fail);}
19564 Overall verdict: pass
19570 .*---------------------------------------------------------------------*
19571 :h3. DECODING BIT STRING DER ,length = 1 EXPLICIT TAG , (constructed )
19572 .*---------------------------------------------------------------------*
19575 <TC - DECODING BIT STRING DER ,length = 1 EXPLICIT TAG , (constructed )>
19583 BERPDU ::= BIT STRING
19585 myValue BERPDU ::='1'B
19591 import from TempA all;
19593 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19598 if (dec_BER_PDU('A00403020780'O) == myValue)
19601 {setverdict(pass);} else {setverdict(fail);}
19606 Overall verdict: pass
19612 .*---------------------------------------------------------------------*
19613 :h3.CER + DER encoding of OCTETSTRING, length = 0 (primitive)
19614 .*---------------------------------------------------------------------*
19617 <TC - CER + DER encoding of OCTETSTRING, length = 0 (primitive)>
19625 BERPDU ::= OCTET STRING
19630 import from TempA all;
19631 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
19632 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
19634 const BERPDU b := ''O
19638 if ((enc_DER_PDU(b) == '0400'O)and(enc_CER_PDU(b) == '0400'O)) {setverdict(pass);} else {setverdict(fail);}
19642 Overall verdict: pass
19648 .*---------------------------------------------------------------------*
19649 :h3.CER + DER encoding of OCTETSTRING, length = 2 (primitive)
19650 .*---------------------------------------------------------------------*
19653 <TC - CER + DER encoding of OCTETSTRING, length = 2 (primitive)>
19661 BERPDU ::= OCTET STRING
19666 import from TempA all;
19667 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
19668 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
19670 const BERPDU b := 'FFFF'O
19674 if ((enc_DER_PDU(b) == '0402FFFF'O)and(enc_CER_PDU(b) == '0402FFFF'O)) {setverdict(pass);} else {setverdict(fail);}
19678 Overall verdict: pass
19684 .*---------------------------------------------------------------------*
19685 :h3.CER + DER encoding of OCTETSTRING, length = 1000 (primitive)
19686 .*---------------------------------------------------------------------*
19689 <TC - CER + DER encoding of OCTETSTRING, length = 1000 (primitive)>
19697 BERPDU ::= OCTET STRING
19702 import from TempA all;
19703 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
19704 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
19706 const BERPDU b := 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O
19710 if ((enc_DER_PDU(b) == '048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)and(enc_CER_PDU(b) == '048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)) {setverdict(pass);} else {setverdict(fail);}
19714 Overall verdict: pass
19720 .*---------------------------------------------------------------------*
19721 :h3.CER(constructed) + DER(primitive) encoding of OCTETSTRING, length = 1001 (ENC_02_014 and ENC_02_015)
19722 .*---------------------------------------------------------------------*
19725 <TC - CER(constructed) + DER(primitive) encoding of OCTETSTRING, length = 1001 (ENC_02_014 and ENC_02_015)>
19733 BERPDU ::= OCTET STRING
19738 import from TempA all;
19739 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
19740 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
19743 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O
19747 if ((enc_DER_PDU(b) == '048203E9FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)and(enc_CER_PDU(b)
19748 == '2480048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0401FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
19752 Overall verdict: pass
19758 .*---------------------------------------------------------------------*
19759 :h3.CER + DER encoding of OCTETSTRING, IMPLICIT TAG length = 2 (primitive)
19760 .*---------------------------------------------------------------------*
19763 <TC - CER + DER encoding of OCTETSTRING, IMPLICIT TAG length = 2 (primitive)>
19771 BERPDU ::= [0] IMPLICIT OCTET STRING
19776 import from TempA all;
19777 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
19778 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
19780 const BERPDU b := 'FFFF'O
19784 if ((enc_DER_PDU(b) == '8002FFFF'O)and(enc_CER_PDU(b) == '8002FFFF'O)) {setverdict(pass);} else {setverdict(fail);}
19788 Overall verdict: pass
19794 .*---------------------------------------------------------------------*
19795 :h3.CER + DER encoding of OCTETSTRING,EXPICIT TAG , length = 2 (constructed)
19796 .*---------------------------------------------------------------------*
19799 <TC - CER + DER encoding of OCTETSTRING,EXPICIT TAG , length = 2 (constructed)>
19807 BERPDU ::= [0] EXPLICIT OCTET STRING
19812 import from TempA all;
19813 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
19814 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
19816 const BERPDU b := 'FFFF'O
19820 if ((enc_DER_PDU(b) == 'A0040402FFFF'O)and(enc_CER_PDU(b) == 'A0800402FFFF0000'O)) {setverdict(pass);} else {setverdict(fail);}
19824 Overall verdict: pass
19830 .*---------------------------------------------------------------------*
19831 :h3. DECODING OCTETSTRING ,length = 0 ,CER +DER (primitive)
19832 .*---------------------------------------------------------------------*
19835 <TC - DECODING OCTETSTRING ,length = 0 ,CER +DER (primitive)>
19843 BERPDU ::= OCTET STRING
19845 myIntegerValue BERPDU ::=''H
19851 import from TempA all;
19853 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19858 if (dec_BER_PDU('0400'O) == myIntegerValue)
19861 {setverdict(pass);} else {setverdict(fail);}
19866 Overall verdict: pass
19872 .*---------------------------------------------------------------------*
19873 :h3. DECODING OCTETSTRING ,length = 0 ,constructed
19874 .*---------------------------------------------------------------------*
19877 <TC - DECODING OCTETSTRING ,length = 0 ,constructed>
19885 BERPDU ::= OCTET STRING
19887 myIntegerValue BERPDU ::=''H
19893 import from TempA all;
19895 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19900 if (dec_BER_PDU('24020400'O) == myIntegerValue)
19903 {setverdict(pass);} else {setverdict(fail);}
19908 Overall verdict: pass
19914 .*---------------------------------------------------------------------*
19915 :h3. DECODING OCTETSTRING ,2xlength = 0 ,constructed
19916 .*---------------------------------------------------------------------*
19919 <TC - DECODING OCTETSTRING ,2xlength = 0 ,constructed>
19927 BERPDU ::= OCTET STRING
19929 myIntegerValue BERPDU ::=''H
19935 import from TempA all;
19937 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19942 if (dec_BER_PDU('240404000400'O) == myIntegerValue)
19945 {setverdict(pass);} else {setverdict(fail);}
19950 Overall verdict: pass
19956 .*---------------------------------------------------------------------*
19957 :h3. DECODING OCTETSTRING ,length = 0 ,constructed, indefinite
19958 .*---------------------------------------------------------------------*
19961 <TC - DECODING OCTETSTRING ,length = 0 ,constructed, indefinite>
19969 BERPDU ::= OCTET STRING
19971 myIntegerValue BERPDU ::=''H
19977 import from TempA all;
19979 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
19984 if (dec_BER_PDU('248004000000'O) == myIntegerValue)
19987 {setverdict(pass);} else {setverdict(fail);}
19992 Overall verdict: pass
19998 .*---------------------------------------------------------------------*
19999 :h3. DECODING OCTETSTRING ,length = 2 ,CER + DER, (primitive)
20000 .*---------------------------------------------------------------------*
20003 <TC - DECODING OCTETSTRING ,length = 2 ,CER + DER, (primitive)>
20011 BERPDU ::= OCTET STRING
20013 myIntegerValue BERPDU ::='FFFF'H
20019 import from TempA all;
20021 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20026 if (dec_BER_PDU('0402FFFF'O) == myIntegerValue)
20029 {setverdict(pass);} else {setverdict(fail);}
20034 Overall verdict: pass
20040 .*---------------------------------------------------------------------*
20041 :h3. DECODING OCTETSTRING ,length = 2 , (primitive, long form)
20042 .*---------------------------------------------------------------------*
20045 <TC - DECODING OCTETSTRING ,length = 2 , (primitive, long form)>
20053 BERPDU ::= OCTET STRING
20055 myIntegerValue BERPDU ::='FFFF'H
20061 import from TempA all;
20063 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20068 if (dec_BER_PDU('048102FFFF'O) == myIntegerValue)
20071 {setverdict(pass);} else {setverdict(fail);}
20076 Overall verdict: pass
20082 .*---------------------------------------------------------------------*
20083 :h3. DECODING OCTETSTRING ,length = 2 ,constructed, short form - short form
20084 .*---------------------------------------------------------------------*
20087 <TC - DECODING OCTETSTRING ,length = 2 ,constructed, short form - short form>
20095 BERPDU ::= OCTET STRING
20097 myIntegerValue BERPDU ::='FFFF'H
20103 import from TempA all;
20105 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20110 if (dec_BER_PDU('24040402FFFF'O) == myIntegerValue)
20113 {setverdict(pass);} else {setverdict(fail);}
20118 Overall verdict: pass
20124 .*---------------------------------------------------------------------*
20125 :h3. DECODING OCTETSTRING ,length = 2 ,constructed, short form - long form
20126 .*---------------------------------------------------------------------*
20129 <TC - DECODING OCTETSTRING ,length = 2 ,constructed, short form - long form>
20137 BERPDU ::= OCTET STRING
20139 myIntegerValue BERPDU ::='FFFF'H
20145 import from TempA all;
20147 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20152 if (dec_BER_PDU('2405048102FFFF'O) == myIntegerValue)
20155 {setverdict(pass);} else {setverdict(fail);}
20160 Overall verdict: pass
20166 .*---------------------------------------------------------------------*
20167 :h3. DECODING OCTETSTRING ,length = 2 ,constructed, long form - long form
20168 .*---------------------------------------------------------------------*
20171 <TC - DECODING OCTETSTRING ,length = 2 ,constructed, long form - long form>
20179 BERPDU ::= OCTET STRING
20181 myIntegerValue BERPDU ::='FFFF'H
20187 import from TempA all;
20189 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20194 if (dec_BER_PDU('248105048102FFFF'O) == myIntegerValue)
20197 {setverdict(pass);} else {setverdict(fail);}
20202 Overall verdict: pass
20208 .*---------------------------------------------------------------------*
20209 :h3. DECODING OCTETSTRING ,length = 2 ,constructed, indefinite form
20210 .*---------------------------------------------------------------------*
20213 <TC - DECODING OCTETSTRING ,length = 2 ,constructed, indefinite form>
20221 BERPDU ::= OCTET STRING
20223 myIntegerValue BERPDU ::='FFFF'H
20229 import from TempA all;
20231 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20236 if (dec_BER_PDU('24800402FFFF0000'O) == myIntegerValue)
20239 {setverdict(pass);} else {setverdict(fail);}
20244 Overall verdict: pass
20250 .*---------------------------------------------------------------------*
20251 :h3. DECODING OCTETSTRING ,2xlength = 2 ,constructed, short form - short form
20252 .*---------------------------------------------------------------------*
20255 <TC - DECODING OCTETSTRING ,2xlength = 2 ,constructed, short form - short form>
20263 BERPDU ::= OCTET STRING
20265 myIntegerValue BERPDU ::='FFFFFFFF'H
20271 import from TempA all;
20273 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20278 if (dec_BER_PDU('24080402FFFF0402FFFF'O) == myIntegerValue)
20281 {setverdict(pass);} else {setverdict(fail);}
20286 Overall verdict: pass
20292 .*---------------------------------------------------------------------*
20293 :h3. DECODING OCTETSTRING ,length = 2 ,constructed form inside constructed form
20294 .*---------------------------------------------------------------------*
20297 <TC - DECODING OCTETSTRING ,length = 2 ,constructed form inside constructed form>
20305 BERPDU ::= OCTET STRING
20307 myIntegerValue BERPDU ::='FFFF'H
20313 import from TempA all;
20315 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20320 if (dec_BER_PDU('240624040402FFFF'O) == myIntegerValue)
20323 {setverdict(pass);} else {setverdict(fail);}
20328 Overall verdict: pass
20334 .*---------------------------------------------------------------------*
20335 :h3. DECODING OCTETSTRING ,length = 1000 ,CER + DER, (primitive)
20336 .*---------------------------------------------------------------------*
20339 <TC - DECODING OCTETSTRING ,length = 1000 ,CER + DER, (primitive)>
20347 BERPDU ::= OCTET STRING
20349 myIntegerValue BERPDU
20350 ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20356 import from TempA all;
20358 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20363 if (dec_BER_PDU('048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue)
20366 {setverdict(pass);} else {setverdict(fail);}
20371 Overall verdict: pass
20377 .*---------------------------------------------------------------------*
20378 :h3. DECODING OCTETSTRING ,length = 1000 , (primitive, longer form)
20379 .*---------------------------------------------------------------------*
20382 <TC - DECODING OCTETSTRING ,length = 1000 , (primitive, longer form)>
20390 BERPDU ::= OCTET STRING
20392 myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20398 import from TempA all;
20400 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20405 if (dec_BER_PDU('04830003E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue)
20408 {setverdict(pass);} else {setverdict(fail);}
20413 Overall verdict: pass
20419 .*---------------------------------------------------------------------*
20420 :h3. DECODING OCTETSTRING ,length = 1000 ,constructed, long form -long form
20421 .*---------------------------------------------------------------------*
20424 <TC - DECODING OCTETSTRING ,length = 1000 ,constructed, long form -long form>
20432 BERPDU ::= OCTET STRING
20434 myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20440 import from TempA all;
20442 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20447 if (dec_BER_PDU('248203EC048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue)
20450 {setverdict(pass);} else {setverdict(fail);}
20455 Overall verdict: pass
20461 .*---------------------------------------------------------------------*
20462 :h3. DECODING OCTETSTRING ,length = 1000 ,constructed, indefinite form
20463 .*---------------------------------------------------------------------*
20466 <TC - DECODING OCTETSTRING ,length = 1000 ,constructed, indefinite form>
20474 BERPDU ::= OCTET STRING
20476 myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20482 import from TempA all;
20484 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20489 if (dec_BER_PDU('2480048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000'O) == myIntegerValue)
20492 {setverdict(pass);} else {setverdict(fail);}
20497 Overall verdict: pass
20503 .*---------------------------------------------------------------------*
20504 :h3. DECODING OCTETSTRING ,2xlength = 1000 ,constructed, short form - short form
20505 .*---------------------------------------------------------------------*
20508 <TC - DECODING OCTETSTRING ,2xlength = 1000 ,constructed, short form - short form>
20516 BERPDU ::= OCTET STRING
20518 myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20524 import from TempA all;
20526 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20531 if (dec_BER_PDU('248207D8048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue)
20534 {setverdict(pass);} else {setverdict(fail);}
20539 Overall verdict: pass
20545 .*---------------------------------------------------------------------*
20546 :h3. DECODING OCTETSTRING ,length = 1001 ,CER (constructed, indefinite form. segmented)
20547 .*---------------------------------------------------------------------*
20550 <TC - DECODING OCTETSTRING ,length = 1001 ,CER (constructed, indefinite form. segmented)>
20558 BERPDU ::= OCTET STRING
20559 myIntegerValue BERPDU ::= 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20566 import from TempA all;
20568 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20573 if (dec_BER_PDU('2480048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0401FF0000'O) == myIntegerValue)
20576 {setverdict(pass);} else {setverdict(fail);}
20581 Overall verdict: pass
20587 .*---------------------------------------------------------------------*
20588 :h3. DECODING OCTETSTRING ,length = 1001 ,DER (primitive)
20589 .*---------------------------------------------------------------------*
20592 <TC - DECODING OCTETSTRING ,length = 1001 ,DER (primitive)>
20600 BERPDU ::= OCTET STRING
20601 myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20609 import from TempA all;
20611 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20616 if (dec_BER_PDU('048203E9FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue)
20619 {setverdict(pass);} else {setverdict(fail);}
20624 Overall verdict: pass
20630 .*---------------------------------------------------------------------*
20631 :h3. DECODING OCTETSTRING ,length = 1001 ,constructed, definite form
20632 .*---------------------------------------------------------------------*
20635 <TC - DECODING OCTETSTRING ,length = 1001 ,constructed, definite form>
20643 BERPDU ::= OCTET STRING
20644 myIntegerValue BERPDU ::= 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H
20651 import from TempA all;
20653 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20658 if (dec_BER_PDU('248203ED048203E9FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue)
20661 {setverdict(pass);} else {setverdict(fail);}
20666 Overall verdict: pass
20672 .*---------------------------------------------------------------------*
20673 :h3. DECODING OCTETSTRING ,length = 2 ,CER + DER,IMPLICIT TAG (primitive)
20674 .*---------------------------------------------------------------------*
20677 <TC - DECODING OCTETSTRING ,length = 2 ,CER + DER,IMPLICIT TAG (primitive)>
20685 BERPDU ::= [0] IMPLICIT OCTET STRING
20687 myIntegerValue BERPDU ::='FFFF'H
20693 import from TempA all;
20695 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20700 if (dec_BER_PDU('8002FFFF'O) == myIntegerValue)
20703 {setverdict(pass);} else {setverdict(fail);}
20708 Overall verdict: pass
20714 .*---------------------------------------------------------------------*
20715 :h3. DECODING OCTETSTRING ,length = 2 ,CER ,EXPLICIT TAG (constructed)
20716 .*---------------------------------------------------------------------*
20719 <TC - DECODING OCTETSTRING ,length = 2 ,CER ,EXPLICIT TAG (constructed)>
20727 BERPDU ::= [0] EXPLICIT OCTET STRING
20729 myIntegerValue BERPDU ::='FFFF'H
20735 import from TempA all;
20737 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20742 if (dec_BER_PDU('A0800402FFFF0000'O) == myIntegerValue)
20745 {setverdict(pass);} else {setverdict(fail);}
20750 Overall verdict: pass
20756 .*---------------------------------------------------------------------*
20757 :h3. DECODING OCTETSTRING ,length = 2 ,DER,EXPLICIT TAG (constructed)
20758 .*---------------------------------------------------------------------*
20761 <TC - DECODING OCTETSTRING ,length = 2 ,DER,EXPLICIT TAG (constructed)>
20769 BERPDU ::= OCTET STRING
20771 myIntegerValue BERPDU ::='FFFF'H
20777 import from TempA all;
20779 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
20784 if (dec_BER_PDU('A0040402FFFF'O) == myIntegerValue)
20787 {setverdict(pass);} else {setverdict(fail);}
20792 Overall verdict: pass
20798 .*---------------------------------------------------------------------*
20799 :h3. DER + CER encoding of NULL
20800 .*---------------------------------------------------------------------*
20803 <TC - DER + CER encoding of NULL >
20804 START OF NULL SECTION
20817 import from TempA all;
20818 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
20819 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
20821 const BERPDU b := NULL
20825 if ((enc_DER_PDU(b) == '0500'O)and(enc_CER_PDU(b) == '0500'O)) {setverdict(pass);} else {setverdict(fail);}
20829 Overall verdict: pass
20835 .*---------------------------------------------------------------------*
20836 :h3. DER + CER encoding of NULL with Context Specific TAG, EXPLICIT
20837 .*---------------------------------------------------------------------*
20840 <TC - DER + CER encoding of NULL with Context Specific TAG, EXPLICIT>
20848 BERPDU ::= [0] EXPLICIT NULL
20853 import from TempA all;
20854 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
20855 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
20857 const BERPDU b := NULL
20861 if ((enc_DER_PDU(b) == 'A0020500'O)and(enc_CER_PDU(b) == 'A08005000000'O)) {setverdict(pass);} else {setverdict(fail);}
20865 Overall verdict: pass
20871 .*---------------------------------------------------------------------*
20872 :h3. DER + CER encoding of NULL with PRIVATE TAG, EXPLICIT
20873 .*---------------------------------------------------------------------*
20876 <TC - DER + CER encoding of NULL with PRIVATE TAG, EXPLICIT>
20884 BERPDU ::= [PRIVATE 1] EXPLICIT NULL
20889 import from TempA all;
20890 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
20891 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
20893 const BERPDU b := NULL
20897 if ((enc_DER_PDU(b) == 'E1020500'O)and(enc_CER_PDU(b) == 'E18005000000'O)) {setverdict(pass);} else {setverdict(fail);}
20901 Overall verdict: pass
20907 .*---------------------------------------------------------------------*
20908 :h3. DER + CER encoding of NULL with APPLICATION TAG, EXPLICIT
20909 .*---------------------------------------------------------------------*
20912 <TC - DER + CER encoding of NULL with APPLICATION TAG, EXPLICIT>
20920 BERPDU ::= [APPLICATION 2] EXPLICIT NULL
20925 import from TempA all;
20926 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
20927 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
20929 const BERPDU b := NULL
20933 if ((enc_DER_PDU(b) == '62020500'O)and(enc_CER_PDU(b) == '628005000000'O)) {setverdict(pass);} else {setverdict(fail);}
20937 Overall verdict: pass
20943 .*---------------------------------------------------------------------*
20944 :h3. DER + CER encoding of NULL with Context Specific TAG, IMPLICIT
20945 .*---------------------------------------------------------------------*
20948 <TC - DER + CER encoding of NULL with Context Specific TAG, IMPLICIT>
20956 BERPDU ::= [0] IMPLICIT NULL
20961 import from TempA all;
20962 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
20963 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
20965 const BERPDU b := NULL
20969 if ((enc_DER_PDU(b) == '8000'O)and(enc_CER_PDU(b) == '8000'O)) {setverdict(pass);} else {setverdict(fail);}
20973 Overall verdict: pass
20979 .*---------------------------------------------------------------------*
20980 :h3. DER + CER encoding of NULL with PRIVATE TAG, IMPLICIT
20981 .*---------------------------------------------------------------------*
20984 <TC - DER + CER encoding of NULL with PRIVATE TAG, IMPLICIT>
20992 BERPDU ::= [PRIVATE 1] IMPLICIT NULL
20997 import from TempA all;
20998 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
20999 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
21001 const BERPDU b := NULL
21005 if ((enc_DER_PDU(b) == 'C100'O)and(enc_CER_PDU(b) == 'C100'O)) {setverdict(pass);} else {setverdict(fail);}
21009 Overall verdict: pass
21015 .*---------------------------------------------------------------------*
21016 :h3. DER + CER encoding of NULL with APPLICATION TAG, IMPLICIT
21017 .*---------------------------------------------------------------------*
21020 <TC - DER + CER encoding of NULL with APPLICATION TAG, IMPLICIT>
21028 BERPDU ::= [APPLICATION 2] IMPLICIT NULL
21033 import from TempA all;
21034 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
21035 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
21037 const BERPDU b := NULL
21041 if ((enc_DER_PDU(b) == '4200'O)and(enc_CER_PDU(b) == '4200'O)) {setverdict(pass);} else {setverdict(fail);}
21045 Overall verdict: pass
21051 .*---------------------------------------------------------------------*
21052 :h3. DECODING NULL, CER+DER
21053 .*---------------------------------------------------------------------*
21056 <TC - DECODING NULL, CER+DER>
21066 myNullValue BERPDU ::= NULL
21072 import from TempA all;
21074 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21079 if (dec_BER_PDU('0500'O) == myNullValue)
21082 {setverdict(pass);} else {setverdict(fail);}
21087 Overall verdict: pass
21093 .*---------------------------------------------------------------------*
21094 :h3. DECODING NULL, (LENGTH OF LENGTH = 1)
21095 .*---------------------------------------------------------------------*
21098 <TC - DECODING NULL, (LENGTH OF LENGTH = 1)>
21108 myNullValue BERPDU ::= NULL
21114 import from TempA all;
21116 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21121 if (dec_BER_PDU('058100'O) == myNullValue)
21124 {setverdict(pass);} else {setverdict(fail);}
21129 Overall verdict: pass
21135 .*---------------------------------------------------------------------*
21136 :h3. DECODING NULL, (LENGTH OF LENGTH = 2)
21137 .*---------------------------------------------------------------------*
21140 <TC - DECODING NULL, (LENGTH OF LENGTH = 2)>
21150 myNullValue BERPDU ::= NULL
21156 import from TempA all;
21158 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21163 if (dec_BER_PDU('05820000'O) == myNullValue)
21166 {setverdict(pass);} else {setverdict(fail);}
21171 Overall verdict: pass
21177 .*---------------------------------------------------------------------*
21178 :h3. DECODING [0] EXPLICIT NULL , DER
21179 .*---------------------------------------------------------------------*
21182 <TC - DECODING [0] EXPLICIT NULL , DER>
21190 BERPDU ::= [0] EXPLICIT NULL
21192 myNullValue BERPDU ::= NULL
21198 import from TempA all;
21200 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21205 if (dec_BER_PDU('A0020500'O) == myNullValue)
21208 {setverdict(pass);} else {setverdict(fail);}
21213 Overall verdict: pass
21219 .*---------------------------------------------------------------------*
21220 :h3. DECODING [0] EXPLICIT NULL, CER
21221 .*---------------------------------------------------------------------*
21224 <TC - DECODING [0] EXPLICIT NULL, CER>
21232 BERPDU ::= [0] EXPLICIT NULL
21234 myNullValue BERPDU ::= NULL
21240 import from TempA all;
21242 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21247 if (dec_BER_PDU('A08005000000'O) == myNullValue)
21250 {setverdict(pass);} else {setverdict(fail);}
21255 Overall verdict: pass
21261 .*---------------------------------------------------------------------*
21262 :h3. DECODING [0] EXPLICIT NULL, Short form - short form
21263 .*---------------------------------------------------------------------*
21266 <TC - DECODING [0] EXPLICIT NULL, Short form - short form>
21274 BERPDU ::= [0] EXPLICIT NULL
21276 myNullValue BERPDU ::= NULL
21282 import from TempA all;
21284 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21289 if (dec_BER_PDU('A0020500'O) == myNullValue)
21292 {setverdict(pass);} else {setverdict(fail);}
21297 Overall verdict: pass
21303 .*---------------------------------------------------------------------*
21304 :h3. DECODING [0] EXPLICIT NULL, Long form - short form
21305 .*---------------------------------------------------------------------*
21308 <TC - DECODING [0] EXPLICIT NULL, Long form - short form>
21316 BERPDU ::= [0] EXPLICIT NULL
21318 myNullValue BERPDU ::= NULL
21324 import from TempA all;
21326 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21331 if (dec_BER_PDU('A081020500'O) == myNullValue)
21334 {setverdict(pass);} else {setverdict(fail);}
21339 Overall verdict: pass
21345 .*---------------------------------------------------------------------*
21346 :h3. DECODING [0] EXPLICIT NULL, Long form Long form
21347 .*---------------------------------------------------------------------*
21350 <TC - DECODING [0] EXPLICIT NULL, Long form Long form>
21358 BERPDU ::= [0] EXPLICIT NULL
21360 myNullValue BERPDU ::= NULL
21366 import from TempA all;
21368 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21373 if (dec_BER_PDU('A08103058100'O) == myNullValue)
21376 {setverdict(pass);} else {setverdict(fail);}
21381 Overall verdict: pass
21387 .*---------------------------------------------------------------------*
21388 :h3. DECODING [PRIVATE 1] EXPLICIT NULL , DER
21389 .*---------------------------------------------------------------------*
21392 <TC - DECODING [PRIVATE 1] EXPLICIT NULL , DER>
21400 BERPDU ::= [PRIVATE 1] EXPLICIT NULL
21402 myNullValue BERPDU ::= NULL
21408 import from TempA all;
21410 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21415 if (dec_BER_PDU('E1020500'O) == myNullValue)
21418 {setverdict(pass);} else {setverdict(fail);}
21423 Overall verdict: pass
21429 .*---------------------------------------------------------------------*
21430 :h3. DECODING [PRIVATE 1] EXPLICIT NULL, CER
21431 .*---------------------------------------------------------------------*
21434 <TC - DECODING [PRIVATE 1] EXPLICIT NULL, CER>
21442 BERPDU ::= [PRIVATE 1] EXPLICIT NULL
21444 myNullValue BERPDU ::= NULL
21450 import from TempA all;
21452 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21457 if (dec_BER_PDU('E18005000000'O) == myNullValue)
21460 {setverdict(pass);} else {setverdict(fail);}
21465 Overall verdict: pass
21471 .*---------------------------------------------------------------------*
21472 :h3. DECODING [PRIVATE 1] EXPLICIT NULL, Short form - short form
21473 .*---------------------------------------------------------------------*
21476 <TC - DECODING [PRIVATE 1] EXPLICIT NULL, Short form - short form>
21484 BERPDU ::= [PRIVATE 1] EXPLICIT NULL
21486 myNullValue BERPDU ::= NULL
21492 import from TempA all;
21494 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21499 if (dec_BER_PDU('E1020500'O) == myNullValue)
21502 {setverdict(pass);} else {setverdict(fail);}
21507 Overall verdict: pass
21513 .*---------------------------------------------------------------------*
21514 :h3. DECODING [PRIVATE 1] EXPLICIT NULL, Long form - short form
21515 .*---------------------------------------------------------------------*
21518 <TC - DECODING [PRIVATE 1] EXPLICIT NULL, Long form - short form>
21526 BERPDU ::= [PRIVATE 1] EXPLICIT NULL
21528 myNullValue BERPDU ::= NULL
21534 import from TempA all;
21536 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21541 if (dec_BER_PDU('E181020500'O) == myNullValue)
21544 {setverdict(pass);} else {setverdict(fail);}
21549 Overall verdict: pass
21555 .*---------------------------------------------------------------------*
21556 :h3. DECODING [PRIVATE 1] EXPLICIT NULL, Long form Long form
21557 .*---------------------------------------------------------------------*
21560 <TC - DECODING [PRIVATE 1] EXPLICIT NULL, Long form Long form>
21568 BERPDU ::= [PRIVATE 1] EXPLICIT NULL
21570 myNullValue BERPDU ::= NULL
21576 import from TempA all;
21578 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21583 if (dec_BER_PDU('E18103058100'O) == myNullValue)
21586 {setverdict(pass);} else {setverdict(fail);}
21591 Overall verdict: pass
21597 .*---------------------------------------------------------------------*
21598 :h3. DECODING [APPLICATION 2] EXPLICIT NULL , DER
21599 .*---------------------------------------------------------------------*
21602 <TC - DECODING [APPLICATION 2] EXPLICIT NULL , DER>
21610 BERPDU ::= [APPLICATION 2] EXPLICIT NULL
21612 myNullValue BERPDU ::= NULL
21618 import from TempA all;
21620 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21625 if (dec_BER_PDU('62020500'O) == myNullValue)
21628 {setverdict(pass);} else {setverdict(fail);}
21633 Overall verdict: pass
21639 .*---------------------------------------------------------------------*
21640 :h3. DECODING [APPLICATION 2] EXPLICIT NULL, CER
21641 .*---------------------------------------------------------------------*
21644 <TC - DECODING [APPLICATION 2] EXPLICIT NULL, CER>
21652 BERPDU ::= [APPLICATION 2] EXPLICIT NULL
21654 myNullValue BERPDU ::= NULL
21660 import from TempA all;
21662 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21667 if (dec_BER_PDU('628005000000'O) == myNullValue)
21670 {setverdict(pass);} else {setverdict(fail);}
21675 Overall verdict: pass
21681 .*---------------------------------------------------------------------*
21682 :h3. DECODING [APPLICATION 2] EXPLICIT NULL, Short form - short form
21683 .*---------------------------------------------------------------------*
21686 <TC - DECODING [APPLICATION 2] EXPLICIT NULL, Short form - short form>
21694 BERPDU ::= [APPLICATION 2] EXPLICIT NULL
21696 myNullValue BERPDU ::= NULL
21702 import from TempA all;
21704 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21709 if (dec_BER_PDU('62020500'O) == myNullValue)
21712 {setverdict(pass);} else {setverdict(fail);}
21717 Overall verdict: pass
21723 .*---------------------------------------------------------------------*
21724 :h3. DECODING [APPLICATION 2] EXPLICIT NULL, Long form - short form
21725 .*---------------------------------------------------------------------*
21728 <TC - DECODING [APPLICATION 2] EXPLICIT NULL, Long form - short form>
21736 BERPDU ::= [APPLICATION 2] EXPLICIT NULL
21738 myNullValue BERPDU ::= NULL
21744 import from TempA all;
21746 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21751 if (dec_BER_PDU('6281020500'O) == myNullValue)
21754 {setverdict(pass);} else {setverdict(fail);}
21759 Overall verdict: pass
21765 .*---------------------------------------------------------------------*
21766 :h3. DECODING [APPLICATION 2] EXPLICIT NULL, Long form Long form
21767 .*---------------------------------------------------------------------*
21770 <TC - DECODING [APPLICATION 2] EXPLICIT NULL, Long form Long form>
21778 BERPDU ::= [APPLICATION 2] EXPLICIT NULL
21780 myNullValue BERPDU ::= NULL
21786 import from TempA all;
21788 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21793 if (dec_BER_PDU('628103058100'O) == myNullValue)
21796 {setverdict(pass);} else {setverdict(fail);}
21801 Overall verdict: pass
21807 .*---------------------------------------------------------------------*
21808 :h3. DECODING [0] IMPLICIT NULL ,Short form CER,DER
21809 .*---------------------------------------------------------------------*
21812 <TC - DECODING [0] IMPLICIT NULL ,Short form CER,DER>
21820 BERPDU ::= [0] IMPLICIT NULL
21822 myNullValue BERPDU ::= NULL
21828 import from TempA all;
21830 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21835 if (dec_BER_PDU('8000'O) == myNullValue)
21838 {setverdict(pass);} else {setverdict(fail);}
21843 Overall verdict: pass
21849 .*---------------------------------------------------------------------*
21850 :h3. DECODING [0] IMPLICIT NULL ,Long form
21851 .*---------------------------------------------------------------------*
21854 <TC - DECODING [0] IMPLICIT NULL ,Long form>
21862 BERPDU ::= [0] IMPLICIT NULL
21864 myNullValue BERPDU ::= NULL
21870 import from TempA all;
21872 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21877 if (dec_BER_PDU('808100'O) == myNullValue)
21880 {setverdict(pass);} else {setverdict(fail);}
21885 Overall verdict: pass
21891 .*---------------------------------------------------------------------*
21892 :h3. DECODING [PRIVATE 1] IMPLICIT NULL ,Short form CER,DER
21893 .*---------------------------------------------------------------------*
21896 <TC - DECODING [PRIVATE 1] IMPLICIT NULL ,Short form CER,DER>
21904 BERPDU ::= [PRIVATE 1] IMPLICIT NULL
21906 myNullValue BERPDU ::= NULL
21912 import from TempA all;
21914 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21919 if (dec_BER_PDU('C100'O) == myNullValue)
21922 {setverdict(pass);} else {setverdict(fail);}
21927 Overall verdict: pass
21933 .*---------------------------------------------------------------------*
21934 :h3. DECODING [PRIVATE 1] IMPLICIT NULL ,Long form
21935 .*---------------------------------------------------------------------*
21938 <TC - DECODING [PRIVATE 1] IMPLICIT NULL ,Long form>
21946 BERPDU ::= [PRIVATE 1] IMPLICIT NULL
21948 myNullValue BERPDU ::= NULL
21954 import from TempA all;
21956 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
21961 if (dec_BER_PDU('C18100'O) == myNullValue)
21964 {setverdict(pass);} else {setverdict(fail);}
21969 Overall verdict: pass
21975 .*---------------------------------------------------------------------*
21976 :h3. DECODING [APPLICATION 2] IMPLICIT NULL ,Short form CER,DER
21977 .*---------------------------------------------------------------------*
21980 <TC - DECODING [APPLICATION 2] IMPLICIT NULL ,Short form CER,DER>
21988 BERPDU ::= [APPLICATION 2] IMPLICIT NULL
21990 myNullValue BERPDU ::= NULL
21996 import from TempA all;
21998 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
22003 if (dec_BER_PDU('4200'O) == myNullValue)
22006 {setverdict(pass);} else {setverdict(fail);}
22011 Overall verdict: pass
22017 .*---------------------------------------------------------------------*
22018 :h3. DECODING [APPLICATION 2] IMPLICIT NULL,Long form
22019 .*---------------------------------------------------------------------*
22022 <TC - DECODING [APPLICATION 2] IMPLICIT NULL,Long form>
22030 BERPDU ::= [APPLICATION 2] IMPLICIT NULL
22032 myNullValue BERPDU ::= NULL
22038 import from TempA all;
22040 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
22045 if (dec_BER_PDU('428100'O) == myNullValue)
22048 {setverdict(pass);} else {setverdict(fail);}
22053 Overall verdict: pass
22059 .*---------------------------------------------------------------------*
22060 :h3.CER + DER encoding of SEQUENCE (EMPTY)
22061 .*---------------------------------------------------------------------*
22064 <TC - CER + DER encoding of SEQUENCE (EMPTY)>
22073 BERPDU ::= SEQUENCE
22075 b BOOLEAN OPTIONAL,
22084 import from TempA all;
22085 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22086 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22088 const BERPDU myValue := {b := omit,
22096 if ((enc_DER_PDU(myValue) == '3000'O)and(enc_CER_PDU(myValue) == '30800000'O)) {setverdict(pass);} else {setverdict(fail);}
22100 Overall verdict: pass
22106 .*---------------------------------------------------------------------*
22107 :h3.CER + DER encoding of SEQUENCE (only one element is used)
22108 .*---------------------------------------------------------------------*
22111 <TC - CER + DER encoding of SEQUENCE (only one element is used)>
22120 BERPDU ::= SEQUENCE
22122 b BOOLEAN OPTIONAL,
22131 import from TempA all;
22132 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22133 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22135 const BERPDU myValue := {b := true,
22143 if ((enc_DER_PDU(myValue) == '30030101FF'O)and(enc_CER_PDU(myValue) == '30800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
22147 Overall verdict: pass
22153 .*---------------------------------------------------------------------*
22154 :h3.CER + DER encoding of SEQUENCE (both elements are used)
22155 .*---------------------------------------------------------------------*
22158 <TC - CER + DER encoding of SEQUENCE (both elements are used)>
22167 BERPDU ::= SEQUENCE
22169 b BOOLEAN OPTIONAL,
22178 import from TempA all;
22179 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22180 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22182 const BERPDU myValue := {b := true,
22190 if ((enc_DER_PDU(myValue) == '30060101FF020105'O)and(enc_CER_PDU(myValue) == '30800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
22194 Overall verdict: pass
22200 .*---------------------------------------------------------------------*
22201 :h3.CER + DER encoding of SEQUENCE (one element is equal to Default)
22202 .*---------------------------------------------------------------------*
22205 <TC - CER + DER encoding of SEQUENCE (one element is equal to Default)>
22214 BERPDU ::= SEQUENCE
22216 b BOOLEAN DEFAULT TRUE,
22225 import from TempA all;
22226 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22227 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22229 const BERPDU myValue := {b := true,
22237 if ((enc_DER_PDU(myValue) == '3003020105'O)and(enc_CER_PDU(myValue) == '30800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
22241 Overall verdict: pass
22247 .*---------------------------------------------------------------------*
22248 :h3.CER + DER encoding of SEQUENCE (one element is not equal to Default)
22249 .*---------------------------------------------------------------------*
22252 <TC - CER + DER encoding of SEQUENCE (one element is not equal to Default)>
22261 BERPDU ::= SEQUENCE
22263 b BOOLEAN DEFAULT TRUE,
22272 import from TempA all;
22273 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22274 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22276 const BERPDU myValue := {b := false,
22284 if ((enc_DER_PDU(myValue) == '3006010100020105'O)and(enc_CER_PDU(myValue) == '30800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);}
22288 Overall verdict: pass
22294 .*---------------------------------------------------------------------*
22295 :h3.CER + DER encoding of SEQUENCE (EMPTY), AUTOMATIC TAGGING
22296 .*---------------------------------------------------------------------*
22299 <TC - CER + DER encoding of SEQUENCE (EMPTY), AUTOMATIC TAGGING>
22313 BERPDU ::= SEQUENCE
22315 b BOOLEAN OPTIONAL,
22324 import from TempA all;
22325 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22326 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22328 const BERPDU myValue := {b := omit,
22336 if ((enc_DER_PDU(myValue) == '3000'O)and(enc_CER_PDU(myValue) == '30800000'O)) {setverdict(pass);} else {setverdict(fail);}
22340 Overall verdict: pass
22346 .*---------------------------------------------------------------------*
22347 :h3.CER + DER encoding of SEQUENCE (only one element is used) AUTOMATIC TAGGING
22348 .*---------------------------------------------------------------------*
22351 <TC - CER + DER encoding of SEQUENCE (only one element is used) AUTOMATIC TAGGING>
22365 BERPDU ::= SEQUENCE
22367 b BOOLEAN OPTIONAL,
22376 import from TempA all;
22377 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22378 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22380 const BERPDU myValue := {b := true,
22388 if ((enc_DER_PDU(myValue) == '30038001FF'O)and(enc_CER_PDU(myValue) == '30808001FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
22392 Overall verdict: pass
22398 .*---------------------------------------------------------------------*
22399 :h3.CER + DER encoding of SEQUENCE (both elements are used) AUTOMATIC TAGGING
22400 .*---------------------------------------------------------------------*
22403 <TC - CER + DER encoding of SEQUENCE (both elements are used) AUTOMATIC TAGGING>
22417 BERPDU ::= SEQUENCE
22419 b BOOLEAN OPTIONAL,
22428 import from TempA all;
22429 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22430 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22432 const BERPDU myValue := {b := true,
22440 if ((enc_DER_PDU(myValue) == '30068001FF810105'O)and(enc_CER_PDU(myValue) == '30808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
22444 Overall verdict: pass
22450 .*---------------------------------------------------------------------*
22451 :h3.CER + DER encoding of SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING
22452 .*---------------------------------------------------------------------*
22455 <TC - CER + DER encoding of SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING>
22469 BERPDU ::= SEQUENCE
22471 b BOOLEAN DEFAULT TRUE,
22480 import from TempA all;
22481 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22482 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22484 const BERPDU myValue := {b := true,
22492 if ((enc_DER_PDU(myValue) == '3003810105'O)and(enc_CER_PDU(myValue) == '30808101050000'O)) {setverdict(pass);} else {setverdict(fail);}
22496 Overall verdict: pass
22502 .*---------------------------------------------------------------------*
22503 :h3.CER + DER encoding of SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING
22504 .*---------------------------------------------------------------------*
22507 <TC - CER + DER encoding of SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING>
22521 BERPDU ::= SEQUENCE
22523 b BOOLEAN DEFAULT TRUE,
22532 import from TempA all;
22533 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22534 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22536 const BERPDU myValue := {b := false,
22544 if ((enc_DER_PDU(myValue) == '3006800100810105'O)and(enc_CER_PDU(myValue) == '30808001008101050000'O)) {setverdict(pass);} else {setverdict(fail);}
22548 Overall verdict: pass
22554 .*---------------------------------------------------------------------*
22555 :h3.CER + DER encoding of SEQUENCE (both elements are used) IMPLICIT TAGS for elements
22556 .*---------------------------------------------------------------------*
22559 <TC - CER + DER encoding of SEQUENCE (both elements are used) IMPLICIT TAGS for elements>
22568 BERPDU ::= SEQUENCE
22570 b [30] IMPLICIT BOOLEAN OPTIONAL,
22571 c [31] IMPLICIT INTEGER OPTIONAL
22579 import from TempA all;
22580 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22581 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22583 const BERPDU myValue := {b := true,
22591 if ((enc_DER_PDU(myValue) == '30079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '30809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
22595 Overall verdict: pass
22601 .*---------------------------------------------------------------------*
22602 :h3.CER + DER encoding of SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
22603 .*---------------------------------------------------------------------*
22606 <TC - CER + DER encoding of SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
22620 BERPDU ::= SEQUENCE
22622 b [30] IMPLICIT BOOLEAN OPTIONAL,
22623 c [31] IMPLICIT INTEGER OPTIONAL
22631 import from TempA all;
22632 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22633 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22635 const BERPDU myValue := {b := true,
22643 if ((enc_DER_PDU(myValue) == '30079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '30809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
22647 Overall verdict: pass
22653 .*---------------------------------------------------------------------*
22654 :h3.CER + DER encoding of SEQUENCE (both elements are used) EXPLICIT TAGS for elements
22655 .*---------------------------------------------------------------------*
22658 <TC - CER + DER encoding of SEQUENCE (both elements are used) EXPLICIT TAGS for elements>
22667 BERPDU ::= SEQUENCE
22669 b [30] EXPLICIT BOOLEAN OPTIONAL,
22670 c [31] EXPLICIT INTEGER OPTIONAL
22678 import from TempA all;
22679 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22680 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22682 const BERPDU myValue := {b := true,
22690 if ((enc_DER_PDU(myValue) == '300BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3080BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
22694 Overall verdict: pass
22700 .*---------------------------------------------------------------------*
22701 :h3.CER + DER encoding of SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
22702 .*---------------------------------------------------------------------*
22705 <TC - CER + DER encoding of SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
22719 BERPDU ::= SEQUENCE
22721 b [30] EXPLICIT BOOLEAN OPTIONAL,
22722 c [31] EXPLICIT INTEGER OPTIONAL
22730 import from TempA all;
22731 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22732 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22734 const BERPDU myValue := {b := true,
22742 if ((enc_DER_PDU(myValue) == '300BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3080BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
22746 Overall verdict: pass
22752 .*---------------------------------------------------------------------*
22753 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are used)
22754 .*---------------------------------------------------------------------*
22757 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are used)>
22766 BERPDU ::= [0] SEQUENCE
22768 b BOOLEAN OPTIONAL,
22777 import from TempA all;
22778 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22779 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22781 const BERPDU myValue := {b := true,
22789 if ((enc_DER_PDU(myValue) == 'A00830060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08030800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
22793 Overall verdict: pass
22799 .*---------------------------------------------------------------------*
22800 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are used), AUTOMATIC TAGGING ENVIRONMENT
22801 .*---------------------------------------------------------------------*
22804 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are used), AUTOMATIC TAGGING ENVIRONMENT>
22818 BERPDU ::= [0] SEQUENCE
22820 b BOOLEAN OPTIONAL,
22829 import from TempA all;
22830 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22831 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22833 const BERPDU myValue := {b := true,
22841 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
22845 Overall verdict: pass
22851 .*---------------------------------------------------------------------*
22852 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT
22853 .*---------------------------------------------------------------------*
22856 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
22870 BERPDU ::= [0] SEQUENCE
22872 b BOOLEAN OPTIONAL,
22881 import from TempA all;
22882 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22883 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22885 const BERPDU myValue := {b := true,
22893 if ((enc_DER_PDU(myValue) == 'A0060101FF020105'O)and(enc_CER_PDU(myValue) == 'A0800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
22897 Overall verdict: pass
22903 .*---------------------------------------------------------------------*
22904 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT
22905 .*---------------------------------------------------------------------*
22908 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
22922 BERPDU ::= [0] SEQUENCE
22924 b BOOLEAN OPTIONAL,
22933 import from TempA all;
22934 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22935 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22937 const BERPDU myValue := {b := true,
22945 if ((enc_DER_PDU(myValue) == 'A00830060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08030800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
22949 Overall verdict: pass
22955 .*---------------------------------------------------------------------*
22956 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used)
22957 .*---------------------------------------------------------------------*
22960 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used)>
22969 BERPDU ::= [0] SEQUENCE
22971 b [0] BOOLEAN OPTIONAL,
22972 c [1] INTEGER OPTIONAL
22980 import from TempA all;
22981 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
22982 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
22984 const BERPDU myValue := {b := true,
22992 if ((enc_DER_PDU(myValue) == 'A00C300AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803080A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
22996 Overall verdict: pass
23002 .*---------------------------------------------------------------------*
23003 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
23004 .*---------------------------------------------------------------------*
23007 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
23021 BERPDU ::= [0] SEQUENCE
23023 b [0] BOOLEAN OPTIONAL,
23024 c [1] INTEGER OPTIONAL
23032 import from TempA all;
23033 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23034 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23036 const BERPDU myValue := {b := true,
23044 if ((enc_DER_PDU(myValue) == 'A00C300AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803080A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
23048 Overall verdict: pass
23054 .*---------------------------------------------------------------------*
23055 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
23056 .*---------------------------------------------------------------------*
23059 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
23073 BERPDU ::= [0] SEQUENCE
23075 b [0] BOOLEAN OPTIONAL,
23076 c [1] INTEGER OPTIONAL
23084 import from TempA all;
23085 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23086 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23088 const BERPDU myValue := {b := true,
23096 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
23100 Overall verdict: pass
23106 .*---------------------------------------------------------------------*
23107 :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
23108 .*---------------------------------------------------------------------*
23111 <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
23125 BERPDU ::= [0] SEQUENCE
23127 b [0] BOOLEAN OPTIONAL,
23128 c [1] INTEGER OPTIONAL
23136 import from TempA all;
23137 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23138 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23140 const BERPDU myValue := {b := true,
23148 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
23152 Overall verdict: pass
23158 .*---------------------------------------------------------------------*
23159 :h3.CER + DER encoding of SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
23160 .*---------------------------------------------------------------------*
23163 <TC - CER + DER encoding of SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
23177 BERPDU ::= SEQUENCE
23179 b [5] BOOLEAN OPTIONAL,
23188 import from TempA all;
23189 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23190 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23192 const BERPDU myValue := {b := true,
23200 if ((enc_DER_PDU(myValue) == '30068501FF020105'O)and(enc_CER_PDU(myValue) == '30808501FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
23204 Overall verdict: pass
23210 .*---------------------------------------------------------------------*
23211 :h3.CER + DER encoding of SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
23212 .*---------------------------------------------------------------------*
23215 <TC - CER + DER encoding of SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
23231 {x INTEGER OPTIONAL,
23236 BERPDU ::= SEQUENCE
23238 b BOOLEAN OPTIONAL,
23239 c INTEGER OPTIONAL,
23240 COMPONENTS OF MySeq
23248 import from TempA all;
23249 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23250 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23252 const BERPDU myValue := {b := true,
23262 if ((enc_DER_PDU(myValue) == '300C8001FF8101058201068301FF'O)and(enc_CER_PDU(myValue) == '30808001FF8101058201068301FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
23266 Overall verdict: pass
23272 .*---------------------------------------------------------------------*
23273 :h3.CER + DER encoding of SEQUENCE , one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
23274 .*---------------------------------------------------------------------*
23277 <TC - CER + DER encoding of SEQUENCE , one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
23292 {x [0] INTEGER OPTIONAL,
23297 BERPDU ::= SEQUENCE
23299 b BOOLEAN OPTIONAL,
23300 c INTEGER OPTIONAL,
23301 COMPONENTS OF MySeq
23309 import from TempA all;
23310 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23311 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23313 const BERPDU myValue := {b := true,
23323 if ((enc_DER_PDU(myValue) == '300C8001FF8101058201068301FF'O)and(enc_CER_PDU(myValue) == '30808001FF8101058201068301FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
23327 Overall verdict: pass
23333 .*---------------------------------------------------------------------*
23334 :h3.CER + DER encoding of SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
23335 .*---------------------------------------------------------------------*
23338 <TC - CER + DER encoding of SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
23354 {x INTEGER OPTIONAL,
23359 BERPDU ::= SEQUENCE
23361 b [0] BOOLEAN OPTIONAL,
23362 c BIT STRING OPTIONAL,
23363 COMPONENTS OF MySeq
23371 import from TempA all;
23372 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23373 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23375 const BERPDU myValue := {b := true,
23385 if ((enc_DER_PDU(myValue) == '300D8001FF030207800201060401FF'O)and(enc_CER_PDU(myValue) == '30808001FF030207800201060401FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
23389 Overall verdict: pass
23395 .*---------------------------------------------------------------------*
23396 :h3.CER + DER encoding of SEQUENCE , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
23397 .*---------------------------------------------------------------------*
23400 <TC - CER + DER encoding of SEQUENCE , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
23415 {x [1] INTEGER OPTIONAL,
23420 BERPDU ::= SEQUENCE
23422 b [0] BOOLEAN OPTIONAL,
23423 c BIT STRING OPTIONAL,
23424 COMPONENTS OF MySeq
23433 import from TempA all;
23434 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23435 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23437 const BERPDU myValue := {b := true,
23447 if ((enc_DER_PDU(myValue) == '300D8001FF030207808101060401FF'O)and(enc_CER_PDU(myValue) == '30808001FF030207808101060401FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
23451 Overall verdict: pass
23457 .*---------------------------------------------------------------------*
23458 :h3.CER + DER encoding of SEQUENCE with CHOICE element, AUTOMATIC TAGS
23459 .*---------------------------------------------------------------------*
23462 <TC - CER + DER encoding of SEQUENCE with CHOICE element, AUTOMATIC TAGS>
23479 BERPDU ::= SEQUENCE
23498 import from TempA all;
23499 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23500 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23502 const BERPDU myValue := {b := {x := true},
23510 if ((enc_DER_PDU(myValue) == '3008A0038001FF810104'O)and(enc_CER_PDU(myValue) == '3080A0808001FF00008101040000'O)) {setverdict(pass);} else {setverdict(fail);}
23514 Overall verdict: pass
23520 .*---------------------------------------------------------------------*
23521 :h3.CER + DER encoding of SEQUENCE with CHOICE element,
23522 .*---------------------------------------------------------------------*
23525 <TC - CER + DER encoding of SEQUENCE with CHOICE element, >
23542 BERPDU ::= SEQUENCE
23561 import from TempA all;
23562 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23563 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23565 const BERPDU myValue := {b := {x := true},
23573 if ((enc_DER_PDU(myValue) == '30060101FF020104'O)and(enc_CER_PDU(myValue) == '30800101FF0201040000'O)) {setverdict(pass);} else {setverdict(fail);}
23577 Overall verdict: pass
23583 .*---------------------------------------------------------------------*
23584 :h3.CER + DER encoding of SEQUENCE with EXTENSION , AUTOMATIC TAGS
23585 .*---------------------------------------------------------------------*
23588 <TC - CER + DER encoding of SEQUENCE with EXTENSION , AUTOMATIC TAGS>
23605 BERPDU ::= SEQUENCE
23627 import from TempA all;
23628 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23629 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23631 const BERPDU myValue := {
23642 if ((enc_DER_PDU(myValue) == '300D8001FF8101FF83020780820104'O)and(enc_CER_PDU(myValue) == '30808001FF8101FF830207808201040000'O)) {setverdict(pass);} else {setverdict(fail);}
23646 Overall verdict: pass
23652 .*---------------------------------------------------------------------*
23653 :h3.CER + DER encoding of SEQUENCE with fields of different types
23654 .*---------------------------------------------------------------------*
23657 <TC - CER + DER encoding of SEQUENCE with fields of different types>
23666 BERPDU ::= SEQUENCE
23671 d ENUMERATED {first ,second ,third},
23676 h OBJECT IDENTIFIER,
23678 j CHOICE {x1 [1] BOOLEAN,
23679 y1 [2] OCTET STRING},
23681 k SEQUENCE{x2 NULL,
23684 l SET { x3 BIT STRING,
23687 m [3] SEQUENCE OF INTEGER,
23688 n [4] SET OF BOOLEAN
23692 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
23699 import from TempA all;
23700 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23701 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23703 const BERPDU myValue := {a := NULL,
23712 j := {x1 := true } ,
23740 if ((enc_DER_PDU(myValue) == '305305000101FF0201020A0100090603312E452B30030207800402FFFF06030002031603414243A1030101FF300505000101FF310C03020780090603312E452B30A3083006020101020102A40831060101FF0101FF'O)and(enc_CER_PDU(myValue) == '308005000101FF0201020A0100090603312E452B30030207800402FFFF06030002031603414243A1800101FF0000308005000101FF0000318003020780090603312E452B300000A380308002010102010200000000A48031800101FF0101FF000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
23744 Overall verdict: pass
23750 .*---------------------------------------------------------------------*
23751 :h3.CER + DER encoding of SEQUENCE with fields of different types, AUTOMATIC TAGS
23752 .*---------------------------------------------------------------------*
23755 <TC - CER + DER encoding of SEQUENCE with fields of different types, AUTOMATIC TAGS>
23769 BERPDU ::= SEQUENCE
23774 d ENUMERATED {first ,second ,third},
23779 h OBJECT IDENTIFIER,
23781 j CHOICE {x1 BOOLEAN,
23784 k SEQUENCE{x2 NULL,
23787 l SET { x3 BIT STRING,
23790 m SEQUENCE OF INTEGER,
23795 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
23802 import from TempA all;
23803 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
23804 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
23806 const BERPDU myValue := {a := NULL,
23815 j := {x1 := true } ,
23843 if ((enc_DER_PDU(myValue) == '304F80008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB0C80020780810603312E452B30AC06020101020102AD060101FF0101FF'O)and(enc_CER_PDU(myValue) == '308080008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB8080020780810603312E452B300000AC800201010201020000AD800101FF0101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
23847 Overall verdict: pass
23853 .*---------------------------------------------------------------------*
23854 :h3. DECODING DER , SEQUENCE (EMPTY)
23855 .*---------------------------------------------------------------------*
23858 <TC - DECODING DER , SEQUENCE (EMPTY)>
23866 BERPDU ::= SEQUENCE
23868 b BOOLEAN OPTIONAL,
23876 import from TempA all;
23878 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
23881 const BERPDU myValue := {b := omit,
23886 if (dec_BER_PDU('3000'O) == myValue)
23890 {setverdict(pass);} else {setverdict(fail);}
23895 Overall verdict: pass
23901 .*---------------------------------------------------------------------*
23902 :h3. DECODING CER , SEQUENCE (EMPTY)
23903 .*---------------------------------------------------------------------*
23906 <TC - DECODING CER , SEQUENCE (EMPTY)>
23914 BERPDU ::= SEQUENCE
23916 b BOOLEAN OPTIONAL,
23924 import from TempA all;
23926 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
23929 const BERPDU myValue := {b := omit,
23934 if (dec_BER_PDU('30800000'O) == myValue)
23938 {setverdict(pass);} else {setverdict(fail);}
23943 Overall verdict: pass
23949 .*---------------------------------------------------------------------*
23950 :h3.DECODING DER , SEQUENCE (only one element is used)
23951 .*---------------------------------------------------------------------*
23954 <TC - DECODING DER , SEQUENCE (only one element is used)>
23962 BERPDU ::= SEQUENCE
23964 b BOOLEAN OPTIONAL,
23973 import from TempA all;
23975 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
23978 const BERPDU myValue := {b := true,
23983 if (dec_BER_PDU('30030101FF'O) == myValue)
23987 {setverdict(pass);} else {setverdict(fail);}
23992 Overall verdict: pass
23998 .*---------------------------------------------------------------------*
23999 :h3.DECODING CER , SEQUENCE (only one element is used)
24000 .*---------------------------------------------------------------------*
24003 <TC - DECODING CER , SEQUENCE (only one element is used)>
24011 BERPDU ::= SEQUENCE
24013 b BOOLEAN OPTIONAL,
24022 import from TempA all;
24024 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24027 const BERPDU myValue := {b := true,
24032 if (dec_BER_PDU('30800101FF0000'O) == myValue)
24036 {setverdict(pass);} else {setverdict(fail);}
24041 Overall verdict: pass
24047 .*---------------------------------------------------------------------*
24048 :h3. DECODING DER , SEQUENCE (both elements are used)
24049 .*---------------------------------------------------------------------*
24052 <TC - DECODING DER , SEQUENCE (both elements are used)>
24060 BERPDU ::= SEQUENCE
24062 b BOOLEAN OPTIONAL,
24071 import from TempA all;
24073 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24076 const BERPDU myValue := {b := true,
24082 if (dec_BER_PDU('30060101FF020105'O) == myValue)
24086 {setverdict(pass);} else {setverdict(fail);}
24091 Overall verdict: pass
24097 .*---------------------------------------------------------------------*
24098 :h3. DECODING DER , SEQUENCE (both elements are used)
24099 .*---------------------------------------------------------------------*
24102 <TC - DECODING DER , SEQUENCE (both elements are used)>
24110 BERPDU ::= SEQUENCE
24112 b BOOLEAN OPTIONAL,
24121 import from TempA all;
24123 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24126 const BERPDU myValue := {b := true,
24132 if (dec_BER_PDU('30800101FF0201050000'O) == myValue)
24136 {setverdict(pass);} else {setverdict(fail);}
24141 Overall verdict: pass
24147 .*---------------------------------------------------------------------*
24148 :h3. DECODING DER , SEQUENCE (one element is equal to Default)
24149 .*---------------------------------------------------------------------*
24152 <TC - DECODING DER , SEQUENCE (one element is equal to Default)>
24160 BERPDU ::= SEQUENCE
24162 b BOOLEAN DEFAULT TRUE,
24170 import from TempA all;
24172 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24175 const BERPDU myValue := {b := true,
24179 if (dec_BER_PDU('3003020105'O) == myValue)
24183 {setverdict(pass);} else {setverdict(fail);}
24188 Overall verdict: pass
24194 .*---------------------------------------------------------------------*
24195 :h3. DECODING CER, SEQUENCE (one element is equal to Default)
24196 .*---------------------------------------------------------------------*
24199 <TC - DECODING CER, SEQUENCE (one element is equal to Default)>
24207 BERPDU ::= SEQUENCE
24209 b BOOLEAN DEFAULT TRUE,
24217 import from TempA all;
24219 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24222 const BERPDU myValue := {b := true,
24226 if (dec_BER_PDU('30800201050000'O) == myValue)
24230 {setverdict(pass);} else {setverdict(fail);}
24235 Overall verdict: pass
24241 .*---------------------------------------------------------------------*
24242 :h3. DECODING DER , SEQUENCE (one element is not equal to Default)
24243 .*---------------------------------------------------------------------*
24246 <TC - DECODING DER , SEQUENCE (one element is not equal to Default)>
24255 BERPDU ::= SEQUENCE
24257 b BOOLEAN DEFAULT TRUE,
24266 import from TempA all;
24268 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24271 const BERPDU myValue := {b := false,
24275 if (dec_BER_PDU('3006010100020105'O) == myValue)
24279 {setverdict(pass);} else {setverdict(fail);}
24284 Overall verdict: pass
24290 .*---------------------------------------------------------------------*
24291 :h3. DECODING CER , SEQUENCE (one element is not equal to Default)
24292 .*---------------------------------------------------------------------*
24295 <TC - DECODING CER , SEQUENCE (one element is not equal to Default)>
24304 BERPDU ::= SEQUENCE
24306 b BOOLEAN DEFAULT TRUE,
24315 import from TempA all;
24317 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24320 const BERPDU myValue := {b := false,
24324 if (dec_BER_PDU('30800101000201050000'O) == myValue)
24328 {setverdict(pass);} else {setverdict(fail);}
24333 Overall verdict: pass
24339 .*---------------------------------------------------------------------*
24340 :h3. DECODING DER , SEQUENCE (EMPTY), AUTOMATIC TAGGING
24341 .*---------------------------------------------------------------------*
24344 <TC - DECODING DER , SEQUENCE (EMPTY), AUTOMATIC TAGGING>
24359 BERPDU ::= SEQUENCE
24361 b BOOLEAN OPTIONAL,
24370 import from TempA all;
24372 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24375 const BERPDU myValue := {b := omit,
24380 if (dec_BER_PDU('3000'O) == myValue)
24384 {setverdict(pass);} else {setverdict(fail);}
24389 Overall verdict: pass
24395 .*---------------------------------------------------------------------*
24396 :h3. DECODING CER , SEQUENCE (EMPTY), AUTOMATIC TAGGING
24397 .*---------------------------------------------------------------------*
24400 <TC - DECODING CER , SEQUENCE (EMPTY), AUTOMATIC TAGGING>
24415 BERPDU ::= SEQUENCE
24417 b BOOLEAN OPTIONAL,
24426 import from TempA all;
24428 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24431 const BERPDU myValue := {b := omit,
24436 if (dec_BER_PDU('30800000'O) == myValue)
24440 {setverdict(pass);} else {setverdict(fail);}
24445 Overall verdict: pass
24451 .*---------------------------------------------------------------------*
24452 :h3. DECODING DER , SEQUENCE (only one element is used) AUTOMATIC TAGGING
24453 .*---------------------------------------------------------------------*
24456 <TC - DECODING DER , SEQUENCE (only one element is used) AUTOMATIC TAGGING>
24472 BERPDU ::= SEQUENCE
24474 b BOOLEAN OPTIONAL,
24483 import from TempA all;
24485 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24488 const BERPDU myValue := {b := true,
24493 if (dec_BER_PDU('30038001FF'O) == myValue)
24497 {setverdict(pass);} else {setverdict(fail);}
24502 Overall verdict: pass
24508 .*---------------------------------------------------------------------*
24509 :h3. DECODING CER , SEQUENCE (only one element is used) AUTOMATIC TAGGING
24510 .*---------------------------------------------------------------------*
24513 <TC - DECODING CER , SEQUENCE (only one element is used) AUTOMATIC TAGGING>
24529 BERPDU ::= SEQUENCE
24531 b BOOLEAN OPTIONAL,
24540 import from TempA all;
24542 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24545 const BERPDU myValue := {b := true,
24550 if (dec_BER_PDU('30808001FF0000'O) == myValue)
24554 {setverdict(pass);} else {setverdict(fail);}
24559 Overall verdict: pass
24565 .*---------------------------------------------------------------------*
24566 :h3. DECODING DER , SEQUENCE (both elements are used) AUTOMATIC TAGGING
24567 .*---------------------------------------------------------------------*
24570 <TC - DECODING DER , SEQUENCE (both elements are used) AUTOMATIC TAGGING>
24586 BERPDU ::= SEQUENCE
24588 b BOOLEAN OPTIONAL,
24598 import from TempA all;
24600 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24603 const BERPDU myValue := {b := true,
24608 if (dec_BER_PDU('30068001FF810105'O) == myValue)
24612 {setverdict(pass);} else {setverdict(fail);}
24617 Overall verdict: pass
24623 .*---------------------------------------------------------------------*
24624 :h3. DECODING CER , SEQUENCE (both elements are used) AUTOMATIC TAGGING
24625 .*---------------------------------------------------------------------*
24628 <TC - DECODING CER , SEQUENCE (both elements are used) AUTOMATIC TAGGING>
24644 BERPDU ::= SEQUENCE
24646 b BOOLEAN OPTIONAL,
24656 import from TempA all;
24658 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24661 const BERPDU myValue := {b := true,
24666 if (dec_BER_PDU('30808001FF8101050000'O) == myValue)
24670 {setverdict(pass);} else {setverdict(fail);}
24675 Overall verdict: pass
24681 .*---------------------------------------------------------------------*
24682 :h3. DECODING DER , SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING
24683 .*---------------------------------------------------------------------*
24686 <TC - DECODING DER , SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING >
24702 BERPDU ::= SEQUENCE
24704 b BOOLEAN DEFAULT TRUE,
24714 import from TempA all;
24716 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24719 const BERPDU myValue := {b := true,
24724 if (dec_BER_PDU('3003810105'O) == myValue)
24728 {setverdict(pass);} else {setverdict(fail);}
24733 Overall verdict: pass
24739 .*---------------------------------------------------------------------*
24740 :h3. DECODING CER , SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING
24741 .*---------------------------------------------------------------------*
24744 <TC - DECODING CER , SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING >
24760 BERPDU ::= SEQUENCE
24762 b BOOLEAN DEFAULT TRUE,
24772 import from TempA all;
24774 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24777 const BERPDU myValue := {b := true,
24782 if (dec_BER_PDU('30808101050000'O) == myValue)
24786 {setverdict(pass);} else {setverdict(fail);}
24791 Overall verdict: pass
24797 .*---------------------------------------------------------------------*
24798 :h3. DECODING DER ,SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING
24799 .*---------------------------------------------------------------------*
24802 <TC - DECODING DER ,SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING>
24818 BERPDU ::= SEQUENCE
24820 b BOOLEAN DEFAULT TRUE,
24830 import from TempA all;
24832 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24835 const BERPDU myValue := {b := false,
24840 if (dec_BER_PDU('3006800100810105'O) == myValue)
24844 {setverdict(pass);} else {setverdict(fail);}
24849 Overall verdict: pass
24855 .*---------------------------------------------------------------------*
24856 :h3. DECODING CER ,SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING
24857 .*---------------------------------------------------------------------*
24860 <TC - DECODING CER ,SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING>
24876 BERPDU ::= SEQUENCE
24878 b BOOLEAN DEFAULT TRUE,
24888 import from TempA all;
24890 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24893 const BERPDU myValue := {b := false,
24898 if (dec_BER_PDU('30808001008101050000'O) == myValue)
24902 {setverdict(pass);} else {setverdict(fail);}
24907 Overall verdict: pass
24913 .*---------------------------------------------------------------------*
24914 :h3. DECODING DER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements
24915 .*---------------------------------------------------------------------*
24918 <TC - DECODING DER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements>
24934 BERPDU ::= SEQUENCE
24936 b [30] IMPLICIT BOOLEAN OPTIONAL,
24937 c [31] IMPLICIT INTEGER OPTIONAL
24945 import from TempA all;
24947 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
24950 const BERPDU myValue := {b := true,
24955 if (dec_BER_PDU('30079E01FF9F1F0105'O) == myValue)
24959 {setverdict(pass);} else {setverdict(fail);}
24964 Overall verdict: pass
24970 .*---------------------------------------------------------------------*
24971 :h3. DECODING CER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements
24972 .*---------------------------------------------------------------------*
24975 <TC - DECODING CER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements>
24991 BERPDU ::= SEQUENCE
24993 b [30] IMPLICIT BOOLEAN OPTIONAL,
24994 c [31] IMPLICIT INTEGER OPTIONAL
25002 import from TempA all;
25004 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25007 const BERPDU myValue := {b := true,
25012 if (dec_BER_PDU('30809E01FF9F1F01050000'O) == myValue)
25016 {setverdict(pass);} else {setverdict(fail);}
25021 Overall verdict: pass
25027 .*---------------------------------------------------------------------*
25028 :h3. DECODING DER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
25029 .*---------------------------------------------------------------------*
25032 <TC - DECODING DER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
25048 BERPDU ::= SEQUENCE
25050 b [30] IMPLICIT BOOLEAN OPTIONAL,
25051 c [31] IMPLICIT INTEGER OPTIONAL
25060 import from TempA all;
25062 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25065 const BERPDU myValue := {b := true,
25071 if (dec_BER_PDU('30079E01FF9F1F0105'O) == myValue)
25075 {setverdict(pass);} else {setverdict(fail);}
25080 Overall verdict: pass
25086 .*---------------------------------------------------------------------*
25087 :h3. DECODING CER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
25088 .*---------------------------------------------------------------------*
25091 <TC - DECODING CER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
25107 BERPDU ::= SEQUENCE
25109 b [30] IMPLICIT BOOLEAN OPTIONAL,
25110 c [31] IMPLICIT INTEGER OPTIONAL
25119 import from TempA all;
25121 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25124 const BERPDU myValue := {b := true,
25130 if (dec_BER_PDU('30809E01FF9F1F01050000'O) == myValue)
25134 {setverdict(pass);} else {setverdict(fail);}
25139 Overall verdict: pass
25145 .*---------------------------------------------------------------------*
25146 :h3. DECODING DER, SEQUENCE (both elements are used) EXPLICIT TAGS for elements
25147 .*---------------------------------------------------------------------*
25150 <TC - DECODING DER, SEQUENCE (both elements are used) EXPLICIT TAGS for elements>
25165 BERPDU ::= SEQUENCE
25167 b [30] EXPLICIT BOOLEAN OPTIONAL,
25168 c [31] EXPLICIT INTEGER OPTIONAL
25177 import from TempA all;
25179 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25182 const BERPDU myValue := {b := true,
25188 if (dec_BER_PDU('300BBE030101FFBF1F03020105'O) == myValue)
25192 {setverdict(pass);} else {setverdict(fail);}
25197 Overall verdict: pass
25203 .*---------------------------------------------------------------------*
25204 :h3. DECODING CER, SEQUENCE (both elements are used) EXPLICIT TAGS for elements
25205 .*---------------------------------------------------------------------*
25208 <TC - DECODING CER, SEQUENCE (both elements are used) EXPLICIT TAGS for elements>
25223 BERPDU ::= SEQUENCE
25225 b [30] EXPLICIT BOOLEAN OPTIONAL,
25226 c [31] EXPLICIT INTEGER OPTIONAL
25235 import from TempA all;
25237 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25240 const BERPDU myValue := {b := true,
25246 if (dec_BER_PDU('3080BE800101FF0000BF1F8002010500000000'O) == myValue)
25250 {setverdict(pass);} else {setverdict(fail);}
25255 Overall verdict: pass
25261 .*---------------------------------------------------------------------*
25262 :h3. DECODING DER , SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
25263 .*---------------------------------------------------------------------*
25266 <TC - DECODING DER , SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
25282 BERPDU ::= SEQUENCE
25284 b [30] EXPLICIT BOOLEAN OPTIONAL,
25285 c [31] EXPLICIT INTEGER OPTIONAL
25293 import from TempA all;
25295 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25298 const BERPDU myValue := {b := true,
25305 if (dec_BER_PDU('300BBE030101FFBF1F03020105'O) == myValue)
25309 {setverdict(pass);} else {setverdict(fail);}
25314 Overall verdict: pass
25320 .*---------------------------------------------------------------------*
25321 :h3. DECODING CER , SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
25322 .*---------------------------------------------------------------------*
25325 <TC - DECODING CER , SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
25341 BERPDU ::= SEQUENCE
25343 b [30] EXPLICIT BOOLEAN OPTIONAL,
25344 c [31] EXPLICIT INTEGER OPTIONAL
25352 import from TempA all;
25354 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25357 const BERPDU myValue := {b := true,
25364 if (dec_BER_PDU('3080BE800101FF0000BF1F8002010500000000'O) == myValue)
25368 {setverdict(pass);} else {setverdict(fail);}
25373 Overall verdict: pass
25379 .*---------------------------------------------------------------------*
25380 :h3. DECODING , DER , TAGGED SEQUENCE (both elements are used)
25381 .*---------------------------------------------------------------------*
25384 <TC - DECODING , DER , TAGGED SEQUENCE (both elements are used)>
25399 BERPDU ::= [0] SEQUENCE
25401 b BOOLEAN OPTIONAL,
25410 import from TempA all;
25412 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25415 const BERPDU myValue := {b := true,
25422 if (dec_BER_PDU('A00830060101FF020105'O) == myValue)
25426 {setverdict(pass);} else {setverdict(fail);}
25431 Overall verdict: pass
25437 .*---------------------------------------------------------------------*
25438 :h3. DECODING , CER , TAGGED SEQUENCE (both elements are used)
25439 .*---------------------------------------------------------------------*
25442 <TC - DECODING , CER , TAGGED SEQUENCE (both elements are used)>
25457 BERPDU ::= [0] SEQUENCE
25459 b BOOLEAN OPTIONAL,
25468 import from TempA all;
25470 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25473 const BERPDU myValue := {b := true,
25480 if (dec_BER_PDU('A08030800101FF02010500000000'O) == myValue)
25484 {setverdict(pass);} else {setverdict(fail);}
25489 Overall verdict: pass
25495 .*---------------------------------------------------------------------*
25496 :h3. DECODING DER , TAGGED SEQUENCE (both elements are used)
25497 .*---------------------------------------------------------------------*
25500 <TC - DECODING DER , TAGGED SEQUENCE (both elements are used)>
25515 BERPDU ::= [0] SEQUENCE
25517 b BOOLEAN OPTIONAL,
25525 import from TempA all;
25527 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25530 const BERPDU myValue := {b := true,
25537 if (dec_BER_PDU('A00830060101FF020105'O) == myValue)
25541 {setverdict(pass);} else {setverdict(fail);}
25546 Overall verdict: pass
25552 .*---------------------------------------------------------------------*
25553 :h3. DECODING CER , TAGGED SEQUENCE (both elements are used)
25554 .*---------------------------------------------------------------------*
25557 <TC - DECODING CER , TAGGED SEQUENCE (both elements are used)>
25572 BERPDU ::= [0] SEQUENCE
25574 b BOOLEAN OPTIONAL,
25582 import from TempA all;
25584 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25587 const BERPDU myValue := {b := true,
25594 if (dec_BER_PDU('A08030800101FF02010500000000'O) == myValue)
25598 {setverdict(pass);} else {setverdict(fail);}
25603 Overall verdict: pass
25609 .*---------------------------------------------------------------------*
25610 :h3. DECODING DER , TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT
25611 .*---------------------------------------------------------------------*
25614 <TC - DECODING DER , TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
25630 BERPDU ::= [0] SEQUENCE
25632 b BOOLEAN OPTIONAL,
25641 import from TempA all;
25643 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25646 const BERPDU myValue := {b := true,
25652 if (dec_BER_PDU('A0060101FF020105'O) == myValue)
25656 {setverdict(pass);} else {setverdict(fail);}
25661 Overall verdict: pass
25667 .*---------------------------------------------------------------------*
25668 :h3. DECODING CER , TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT
25669 .*---------------------------------------------------------------------*
25672 <TC - DECODING CER , TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
25688 BERPDU ::= [0] SEQUENCE
25690 b BOOLEAN OPTIONAL,
25699 import from TempA all;
25701 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25704 const BERPDU myValue := {b := true,
25710 if (dec_BER_PDU('A0800101FF0201050000'O) == myValue)
25714 {setverdict(pass);} else {setverdict(fail);}
25719 Overall verdict: pass
25725 .*---------------------------------------------------------------------*
25726 :h3. DECODING DER , TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT
25727 .*---------------------------------------------------------------------*
25730 <TC - DECODING DER , TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
25746 BERPDU ::= [0] SEQUENCE
25748 b BOOLEAN OPTIONAL,
25757 import from TempA all;
25759 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25762 const BERPDU myValue := {b := true,
25769 if (dec_BER_PDU('A00830060101FF020105'O) == myValue)
25773 {setverdict(pass);} else {setverdict(fail);}
25778 Overall verdict: pass
25784 .*---------------------------------------------------------------------*
25785 :h3. DECODING CER , TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT
25786 .*---------------------------------------------------------------------*
25789 <TC - DECODING CER , TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
25805 BERPDU ::= [0] SEQUENCE
25807 b BOOLEAN OPTIONAL,
25816 import from TempA all;
25818 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25821 const BERPDU myValue := {b := true,
25828 if (dec_BER_PDU('A08030800101FF02010500000000'O) == myValue)
25832 {setverdict(pass);} else {setverdict(fail);}
25837 Overall verdict: pass
25843 .*---------------------------------------------------------------------*
25844 :h3. DECODING DER, TAGGED SEQUENCE (both elements are TAGGED and used)
25845 .*---------------------------------------------------------------------*
25848 <TC - DECODING DER, TAGGED SEQUENCE (both elements are TAGGED and used)>
25863 BERPDU ::= [0] SEQUENCE
25865 b [0] BOOLEAN OPTIONAL,
25866 c [1] INTEGER OPTIONAL
25875 import from TempA all;
25877 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25880 const BERPDU myValue := {b := true,
25887 if (dec_BER_PDU('A00C300AA0030101FFA103020105'O) == myValue)
25891 {setverdict(pass);} else {setverdict(fail);}
25896 Overall verdict: pass
25902 .*---------------------------------------------------------------------*
25903 :h3. DECODING CER, TAGGED SEQUENCE (both elements are TAGGED and used)
25904 .*---------------------------------------------------------------------*
25907 <TC - DECODING CER, TAGGED SEQUENCE (both elements are TAGGED and used)>
25922 BERPDU ::= [0] SEQUENCE
25924 b [0] BOOLEAN OPTIONAL,
25925 c [1] INTEGER OPTIONAL
25934 import from TempA all;
25936 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25939 const BERPDU myValue := {b := true,
25946 if (dec_BER_PDU('A0803080A0800101FF0000A180020105000000000000'O) == myValue)
25950 {setverdict(pass);} else {setverdict(fail);}
25955 Overall verdict: pass
25961 .*---------------------------------------------------------------------*
25962 :h3. DECODING DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
25963 .*---------------------------------------------------------------------*
25966 <TC - DECODING DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
25982 BERPDU ::= [0] SEQUENCE
25984 b [0] BOOLEAN OPTIONAL,
25985 c [1] INTEGER OPTIONAL
25993 import from TempA all;
25995 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
25998 const BERPDU myValue := {b := true,
26005 if (dec_BER_PDU('A00C300AA0030101FFA103020105'O) == myValue)
26009 {setverdict(pass);} else {setverdict(fail);}
26014 Overall verdict: pass
26020 .*---------------------------------------------------------------------*
26021 :h3. DECODING CER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
26022 .*---------------------------------------------------------------------*
26025 <TC - DECODING CER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
26041 BERPDU ::= [0] SEQUENCE
26043 b [0] BOOLEAN OPTIONAL,
26044 c [1] INTEGER OPTIONAL
26052 import from TempA all;
26054 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26057 const BERPDU myValue := {b := true,
26064 if (dec_BER_PDU('A0803080A0800101FF0000A180020105000000000000'O) == myValue)
26068 {setverdict(pass);} else {setverdict(fail);}
26073 Overall verdict: pass
26079 .*---------------------------------------------------------------------*
26080 :h3. DECODING , DER , TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
26081 .*---------------------------------------------------------------------*
26084 <TC - DECODING , DER , TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
26100 BERPDU ::= [0] SEQUENCE
26102 b [0] BOOLEAN OPTIONAL,
26103 c [1] INTEGER OPTIONAL
26111 import from TempA all;
26113 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26116 const BERPDU myValue := {b := true,
26122 if (dec_BER_PDU('A0068001FF810105'O) == myValue)
26126 {setverdict(pass);} else {setverdict(fail);}
26131 Overall verdict: pass
26137 .*---------------------------------------------------------------------*
26138 :h3. DECODING , CER , TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
26139 .*---------------------------------------------------------------------*
26142 <TC - DECODING , CER , TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
26158 BERPDU ::= [0] SEQUENCE
26160 b [0] BOOLEAN OPTIONAL,
26161 c [1] INTEGER OPTIONAL
26169 import from TempA all;
26171 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26174 const BERPDU myValue := {b := true,
26180 if (dec_BER_PDU('A0808001FF8101050000'O) == myValue)
26184 {setverdict(pass);} else {setverdict(fail);}
26189 Overall verdict: pass
26195 .*---------------------------------------------------------------------*
26196 :h3. DECODING , DER , TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
26197 .*---------------------------------------------------------------------*
26200 <TC - DECODING , DER , TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
26216 BERPDU ::= [0] SEQUENCE
26218 b [0] BOOLEAN OPTIONAL,
26219 c [1] INTEGER OPTIONAL
26227 import from TempA all;
26229 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26232 const BERPDU myValue := {b := true,
26238 if (dec_BER_PDU('A0068001FF810105'O) == myValue)
26242 {setverdict(pass);} else {setverdict(fail);}
26247 Overall verdict: pass
26253 .*---------------------------------------------------------------------*
26254 :h3. DECODING , CER , TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
26255 .*---------------------------------------------------------------------*
26258 <TC - DECODING , CER , TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
26274 BERPDU ::= [0] SEQUENCE
26276 b [0] BOOLEAN OPTIONAL,
26277 c [1] INTEGER OPTIONAL
26285 import from TempA all;
26287 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26290 const BERPDU myValue := {b := true,
26296 if (dec_BER_PDU('A0808001FF8101050000'O) == myValue)
26300 {setverdict(pass);} else {setverdict(fail);}
26305 Overall verdict: pass
26311 .*---------------------------------------------------------------------*
26312 :h3. DECODING ,DER, SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
26313 .*---------------------------------------------------------------------*
26316 <TC - DECODING ,DER, SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
26332 BERPDU ::= SEQUENCE
26334 b [5] BOOLEAN OPTIONAL,
26343 import from TempA all;
26345 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26348 const BERPDU myValue := {b := true,
26354 if (dec_BER_PDU('30068501FF020105'O) == myValue)
26358 {setverdict(pass);} else {setverdict(fail);}
26363 Overall verdict: pass
26369 .*---------------------------------------------------------------------*
26370 :h3. DECODING ,CER, SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
26371 .*---------------------------------------------------------------------*
26374 <TC - DECODING ,CER, SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
26390 BERPDU ::= SEQUENCE
26392 b [5] BOOLEAN OPTIONAL,
26401 import from TempA all;
26403 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26406 const BERPDU myValue := {b := true,
26412 if (dec_BER_PDU('30808501FF0201050000'O) == myValue)
26416 {setverdict(pass);} else {setverdict(fail);}
26421 Overall verdict: pass
26427 .*---------------------------------------------------------------------*
26428 :h3. DECODING ,DER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
26429 .*---------------------------------------------------------------------*
26432 <TC - DECODING ,DER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
26448 {x INTEGER OPTIONAL,
26453 BERPDU ::= SEQUENCE
26455 b BOOLEAN OPTIONAL,
26456 c INTEGER OPTIONAL,
26457 COMPONENTS OF MySeq
26465 import from TempA all;
26467 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26470 const BERPDU myValue := {b := true,
26479 if (dec_BER_PDU('300C8001FF8101058201068301FF'O) == myValue)
26483 {setverdict(pass);} else {setverdict(fail);}
26488 Overall verdict: pass
26494 .*---------------------------------------------------------------------*
26495 :h3. DECODING ,CER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
26496 .*---------------------------------------------------------------------*
26499 <TC - DECODING ,CER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
26516 {x INTEGER OPTIONAL,
26521 BERPDU ::= SEQUENCE
26523 b BOOLEAN OPTIONAL,
26524 c INTEGER OPTIONAL,
26525 COMPONENTS OF MySeq
26533 import from TempA all;
26535 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26537 const BERPDU myValue := {b := true,
26547 if (dec_BER_PDU('30808001FF8101058201068301FF0000'O) == myValue)
26551 {setverdict(pass);} else {setverdict(fail);}
26556 Overall verdict: pass
26562 .*---------------------------------------------------------------------*
26563 :h3. DECODING ,DER, SEQUENCE ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
26564 .*---------------------------------------------------------------------*
26567 <TC - DECODING ,DER, SEQUENCE ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
26583 {x [0] INTEGER OPTIONAL,
26588 BERPDU ::= SEQUENCE
26590 b BOOLEAN OPTIONAL,
26591 c INTEGER OPTIONAL,
26592 COMPONENTS OF MySeq
26601 import from TempA all;
26603 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26606 const BERPDU myValue := {b := true,
26615 if (dec_BER_PDU('300C8001FF8101058201068301FF'O) == myValue)
26619 {setverdict(pass);} else {setverdict(fail);}
26624 Overall verdict: pass
26630 .*---------------------------------------------------------------------*
26631 :h3. DECODING ,CER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
26632 .*---------------------------------------------------------------------*
26635 <TC - DECODING ,CER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
26652 {x [0] INTEGER OPTIONAL,
26657 BERPDU ::= SEQUENCE
26659 b BOOLEAN OPTIONAL,
26660 c INTEGER OPTIONAL,
26661 COMPONENTS OF MySeq
26671 import from TempA all;
26673 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26676 const BERPDU myValue := {b := true,
26685 if (dec_BER_PDU('30808001FF8101058201068301FF0000'O) == myValue)
26689 {setverdict(pass);} else {setverdict(fail);}
26694 Overall verdict: pass
26700 .*---------------------------------------------------------------------*
26701 :h3. DECODING ,DER, SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
26702 .*---------------------------------------------------------------------*
26705 <TC - DECODING ,DER, SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
26722 {x INTEGER OPTIONAL,
26727 BERPDU ::= SEQUENCE
26729 b [0] BOOLEAN OPTIONAL,
26730 c BIT STRING OPTIONAL,
26731 COMPONENTS OF MySeq
26738 import from TempA all;
26740 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26744 const BERPDU myValue := {b := true,
26752 if (dec_BER_PDU('300D8001FF030207800201060401FF'O) == myValue)
26756 {setverdict(pass);} else {setverdict(fail);}
26761 Overall verdict: pass
26767 .*---------------------------------------------------------------------*
26768 :h3. DECODING ,CER, SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
26769 .*---------------------------------------------------------------------*
26772 <TC - DECODING ,CER, SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
26789 {x INTEGER OPTIONAL,
26794 BERPDU ::= SEQUENCE
26796 b [0] BOOLEAN OPTIONAL,
26797 c BIT STRING OPTIONAL,
26798 COMPONENTS OF MySeq
26808 import from TempA all;
26810 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26813 const BERPDU myValue := {b := true,
26821 if (dec_BER_PDU('30808001FF030207800201060401FF0000'O) == myValue)
26825 {setverdict(pass);} else {setverdict(fail);}
26830 Overall verdict: pass
26836 .*---------------------------------------------------------------------*
26837 :h3. DECODING ,DER, SEQUENCE , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
26838 .*---------------------------------------------------------------------*
26841 <TC - DECODING ,DER, SEQUENCE , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
26858 {x [1] INTEGER OPTIONAL,
26863 BERPDU ::= SEQUENCE
26865 b [0] BOOLEAN OPTIONAL,
26866 c BIT STRING OPTIONAL,
26867 COMPONENTS OF MySeq
26874 import from TempA all;
26876 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26880 const BERPDU myValue := {b := true,
26889 if (dec_BER_PDU('300D8001FF030207808101060401FF'O) == myValue)
26893 {setverdict(pass);} else {setverdict(fail);}
26898 Overall verdict: pass
26904 .*---------------------------------------------------------------------*
26905 :h3. DECODING ,CER, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
26906 .*---------------------------------------------------------------------*
26909 <TC - DECODING ,CER, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
26926 {x [1] INTEGER OPTIONAL,
26931 BERPDU ::= SEQUENCE
26933 b [0] BOOLEAN OPTIONAL,
26934 c BIT STRING OPTIONAL,
26935 COMPONENTS OF MySeq
26945 import from TempA all;
26947 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
26950 const BERPDU myValue := {b := true,
26959 if (dec_BER_PDU('30808001FF030207808101060401FF0000'O) == myValue)
26963 {setverdict(pass);} else {setverdict(fail);}
26968 Overall verdict: pass
26974 .*---------------------------------------------------------------------*
26975 :h3. DECODING ,DER, SEQUENCE with CHOICE element, AUTOMATIC TAGS
26976 .*---------------------------------------------------------------------*
26979 <TC - DECODING ,DER, SEQUENCE with CHOICE element, AUTOMATIC TAGS>
26995 BERPDU ::= SEQUENCE
27014 import from TempA all;
27016 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27019 const BERPDU myValue := {b := {x := true},
27027 if (dec_BER_PDU('3008A0038001FF810104'O) == myValue)
27031 {setverdict(pass);} else {setverdict(fail);}
27036 Overall verdict: pass
27042 .*---------------------------------------------------------------------*
27043 :h3. DECODING ,CER, SEQUENCE with CHOICE element, AUTOMATIC TAGS
27044 .*---------------------------------------------------------------------*
27047 <TC - DECODING ,CER, SEQUENCE with CHOICE element, AUTOMATIC TAGS>
27062 BERPDU ::= SEQUENCE
27080 import from TempA all;
27082 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27085 const BERPDU myValue := {b := {x := true},
27092 if (dec_BER_PDU('3080A0808001FF00008101040000'O) == myValue)
27096 {setverdict(pass);} else {setverdict(fail);}
27101 Overall verdict: pass
27107 .*---------------------------------------------------------------------*
27108 :h3. DECODING ,DER, SEQUENCE with CHOICE element,
27109 .*---------------------------------------------------------------------*
27112 <TC - DECODING ,DER, SEQUENCE with CHOICE element, >
27127 BERPDU ::= SEQUENCE
27145 import from TempA all;
27147 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27149 const BERPDU myValue := {b := {x := true},
27157 if (dec_BER_PDU('30060101FF020104'O) == myValue)
27161 {setverdict(pass);} else {setverdict(fail);}
27166 Overall verdict: pass
27172 .*---------------------------------------------------------------------*
27173 :h3. DECODING ,CER, SEQUENCE with CHOICE element,
27174 .*---------------------------------------------------------------------*
27177 <TC - DECODING ,CER, SEQUENCE with CHOICE element, >
27192 BERPDU ::= SEQUENCE
27209 import from TempA all;
27211 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27214 const BERPDU myValue := {b := {x := true},
27221 if (dec_BER_PDU('30800101FF0201040000'O) == myValue)
27225 {setverdict(pass);} else {setverdict(fail);}
27230 Overall verdict: pass
27236 .*---------------------------------------------------------------------*
27237 :h3. DECODING ,DER,SEQUENCE with EXTENSION , AUTOMATIC TAGS
27238 .*---------------------------------------------------------------------*
27241 <TC - DECODING ,DER,SEQUENCE with EXTENSION , AUTOMATIC TAGS>
27257 BERPDU ::= SEQUENCE
27277 import from TempA all;
27279 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27282 const BERPDU myValue := {
27291 if (dec_BER_PDU('300D8001FF8101FF83020780820104'O) == myValue)
27295 {setverdict(pass);} else {setverdict(fail);}
27300 Overall verdict: pass
27306 .*---------------------------------------------------------------------*
27307 :h3. DECODING ,CER, SEQUENCE with EXTENSION , AUTOMATIC TAGS
27308 .*---------------------------------------------------------------------*
27311 <TC - DECODING ,CER, SEQUENCE with EXTENSION , AUTOMATIC TAGS>
27327 BERPDU ::= SEQUENCE
27347 import from TempA all;
27349 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27352 const BERPDU myValue := {
27361 if (dec_BER_PDU('30808001FF8101FF830207808201040000'O) == myValue)
27365 {setverdict(pass);} else {setverdict(fail);}
27370 Overall verdict: pass
27376 .*---------------------------------------------------------------------*
27377 :h3. DECODING SEQUENCE with Long Form , AUTOMATIC TAGS
27378 .*---------------------------------------------------------------------*
27381 <TC - DECODING SEQUENCE with Long Form , AUTOMATIC TAGS>
27397 BERPDU ::= SEQUENCE
27417 import from TempA all;
27419 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27422 const BERPDU myValue := {
27431 if (dec_BER_PDU('308300000D8001FF8101FF83020780820104'O) == myValue)
27435 {setverdict(pass);} else {setverdict(fail);}
27440 Overall verdict: pass
27446 .*---------------------------------------------------------------------*
27447 :h3. DECODING , DER, SEQUENCE with fields of different types ,
27448 .*---------------------------------------------------------------------*
27451 <TC - DECODING , DER, SEQUENCE with fields of different types ,>
27465 BERPDU ::= SEQUENCE
27470 d ENUMERATED {first ,second ,third},
27475 h OBJECT IDENTIFIER,
27477 j CHOICE {x1 [1] BOOLEAN,
27478 y1 [2] OCTET STRING},
27480 k SEQUENCE{x2 NULL,
27483 l SET { x3 BIT STRING,
27486 m [3] SEQUENCE OF INTEGER,
27487 n [4] SET OF BOOLEAN
27491 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
27498 import from TempA all;
27500 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27503 const BERPDU myValue := {a := NULL,
27512 j := {x1 := true } ,
27531 if (dec_BER_PDU('304505000101FF0201020A0100030207800402FFFF06030002031603414243A1030101FF300505000101FF3106030207800500A3083006020101020102A40831060101FF0101FF'O) == myValue)
27535 {setverdict(pass);} else {setverdict(fail);}
27540 Overall verdict: pass
27546 .*---------------------------------------------------------------------*
27547 :h3. DECODING , DER, SEQUENCE with fields of different types ,
27548 .*---------------------------------------------------------------------*
27551 <TC - DECODING , DER, SEQUENCE with fields of different types ,>
27565 BERPDU ::= SEQUENCE
27570 d ENUMERATED {first ,second ,third},
27575 h OBJECT IDENTIFIER,
27577 j CHOICE {x1 [1] BOOLEAN,
27578 y1 [2] OCTET STRING},
27580 k SEQUENCE{x2 NULL,
27583 l SET { x3 BIT STRING,
27586 m [3] SEQUENCE OF INTEGER,
27587 n [4] SET OF BOOLEAN
27591 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
27598 import from TempA all;
27600 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27603 const BERPDU myValue := {a := NULL,
27607 // e := 1.0, 090603312E452B30
27612 j := {x1 := true } ,
27631 if (dec_BER_PDU('308005000101FF0201020A0100030207800402FFFF06030002031603414243A1800101FF0000308005000101FF000031800302078005000000A380308002010102010200000000A48031800101FF0101FF000000000000'O) == myValue)
27635 {setverdict(pass);} else {setverdict(fail);}
27640 Overall verdict: pass
27646 .*---------------------------------------------------------------------*
27647 :h3. DECODING , DER, SEQUENCE with fields of different types , AUTOMATIC TAGS
27648 .*---------------------------------------------------------------------*
27651 <TC - DECODING , DER, SEQUENCE with fields of different types , AUTOMATIC TAGS>
27666 BERPDU ::= SEQUENCE
27671 d ENUMERATED {first ,second ,third},
27676 h OBJECT IDENTIFIER,
27678 j CHOICE {x1 BOOLEAN,
27681 k SEQUENCE{x2 NULL,
27684 l SET { x3 BIT STRING,
27687 m SEQUENCE OF INTEGER,
27690 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
27697 import from TempA all;
27699 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27702 const BERPDU myValue := {a := NULL,
27711 j := {x1 := true } ,
27731 if (dec_BER_PDU('304380008101FF8201028301008400850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB06800207808100AC06020101020102AD060101FF0101FF'O) == myValue)
27735 {setverdict(pass);} else {setverdict(fail);}
27740 Overall verdict: pass
27746 .*---------------------------------------------------------------------*
27747 :h3. DECODING , DER, SEQUENCE with fields of different types ,AUTOMATIC TAGS
27748 .*---------------------------------------------------------------------*
27751 <TC - DECODING , DER, SEQUENCE with fields of different types ,AUTOMATIC TAGS>
27765 BERPDU ::= SEQUENCE
27770 d ENUMERATED {first ,second ,third},
27775 h OBJECT IDENTIFIER,
27777 j CHOICE {x1 BOOLEAN,
27780 k SEQUENCE{x2 NULL,
27783 l SET { x3 BIT STRING,
27786 m SEQUENCE OF INTEGER,
27789 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
27797 import from TempA all;
27799 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
27802 const BERPDU myValue := {a := NULL,
27811 j := {x1 := true } ,
27831 if (dec_BER_PDU('308080008101FF8201028301008400850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB808002078081000000AC800201010201020000AD800101FF0101FF00000000'O) == myValue)
27835 {setverdict(pass);} else {setverdict(fail);}
27840 Overall verdict: pass
27846 .*---------------------------------------------------------------------*
27847 :h3.CER + DER encoding of SEQUENCE OF INTEGER (empty)
27848 .*---------------------------------------------------------------------*
27851 <TC - CER + DER encoding of SEQUENCE OF INTEGER (empty)>
27860 BERPDU ::= SEQUENCE OF INTEGER
27868 import from TempA all;
27869 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
27870 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
27872 const BERPDU myValue := { }
27879 if ((enc_DER_PDU(myValue) == '3000'O)and(enc_CER_PDU(myValue) == '30800000'O)) {setverdict(pass);} else {setverdict(fail);}
27883 Overall verdict: pass
27889 .*---------------------------------------------------------------------*
27890 :h3.CER + DER encoding of SEQUENCE OF BOOLEAN
27891 .*---------------------------------------------------------------------*
27894 <TC - CER + DER encoding of SEQUENCE OF BOOLEAN>
27903 BERPDU ::= SEQUENCE OF BOOLEAN
27911 import from TempA all;
27912 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
27913 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
27915 const BERPDU myValue := {true, false }
27922 if ((enc_DER_PDU(myValue) == '30060101FF010100'O)and(enc_CER_PDU(myValue) == '30800101FF0101000000'O)) {setverdict(pass);} else {setverdict(fail);}
27926 Overall verdict: pass
27932 .*---------------------------------------------------------------------*
27933 :h3.CER + DER encoding of SEQUENCE OF OCTET STRING
27934 .*---------------------------------------------------------------------*
27937 <TC - CER + DER encoding of SEQUENCE OF OCTET STRING >
27946 BERPDU ::= SEQUENCE OF OCTET STRING
27952 import from TempA all;
27953 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
27954 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
27956 const BERPDU myValue := {'FFFF'O, 'AB'O };
27960 if ((enc_DER_PDU(myValue) == '30070402FFFF0401AB'O)and(enc_CER_PDU(myValue) == '30800402FFFF0401AB0000'O)) {setverdict(pass);} else {setverdict(fail);}
27964 Overall verdict: pass
27970 .*---------------------------------------------------------------------*
27971 :h3.CER + DER encoding of SEQUENCE OF SEQUENCE
27972 .*---------------------------------------------------------------------*
27975 <TC - CER + DER encoding of SEQUENCE OF SEQUENCE >
27984 BERPDU ::= SEQUENCE OF SEQUENCE {a INTEGER, b BOOLEAN}
27990 import from TempA all;
27991 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
27992 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
27994 const BERPDU myValue := {
28009 if ((enc_DER_PDU(myValue) == '301030060201050101FF3006020103010100'O)and(enc_CER_PDU(myValue) == '308030800201050101FF0000308002010301010000000000'O)) {setverdict(pass);} else {setverdict(fail);}
28013 Overall verdict: pass
28019 .*---------------------------------------------------------------------*
28020 :h3.CER + DER encoding of SEQUENCE OF SET
28021 .*---------------------------------------------------------------------*
28024 <TC - CER + DER encoding of SEQUENCE OF SET >
28033 BERPDU ::= SEQUENCE OF SET {a INTEGER, b BOOLEAN}
28039 import from TempA all;
28040 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
28041 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
28043 const BERPDU myValue := {
28058 if ((enc_DER_PDU(myValue) == '301031060101FF0201053106010100020103'O)and(enc_CER_PDU(myValue) == '308031800101FF0201050000318001010002010300000000'O)) {setverdict(pass);} else {setverdict(fail);}
28062 Overall verdict: pass
28068 .*---------------------------------------------------------------------*
28069 :h3.CER + DER encoding of SEQUENCE OF CHOICE
28070 .*---------------------------------------------------------------------*
28073 <TC - CER + DER encoding of SEQUENCE OF CHOICE >
28082 BERPDU ::= SEQUENCE OF CHOICE{a INTEGER, b BOOLEAN}
28088 import from TempA all;
28089 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
28090 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
28092 const BERPDU myValue := {
28105 if ((enc_DER_PDU(myValue) == '3006020105010100'O)and(enc_CER_PDU(myValue) == '30800201050101000000'O)) {setverdict(pass);} else {setverdict(fail);}
28109 Overall verdict: pass
28115 .*---------------------------------------------------------------------*
28116 :h3.CER + DER encoding of SEQUENCE OF SEQUENCE OF
28117 .*---------------------------------------------------------------------*
28120 <TC - CER + DER encoding of SEQUENCE OF SEQUENCE OF>
28129 BERPDU ::= SEQUENCE OF SEQUENCE OF INTEGER
28135 import from TempA all;
28136 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
28137 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
28139 const BERPDU myValue := {
28155 if ((enc_DER_PDU(myValue) == '301630090201050201060201073009020101020102020103'O)and(enc_CER_PDU(myValue) == '308030800201050201060201070000308002010102010202010300000000'O)) {setverdict(pass);} else {setverdict(fail);}
28159 Overall verdict: pass
28165 .*---------------------------------------------------------------------*
28166 :h3.CER + DER encoding of SEQUENCE OF SET OF
28167 .*---------------------------------------------------------------------*
28170 <TC - CER + DER encoding of SEQUENCE OF SET OF>
28179 BERPDU ::= SEQUENCE OF SET OF INTEGER
28185 import from TempA all;
28186 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
28187 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
28189 const BERPDU myValue := {
28205 if ((enc_DER_PDU(myValue) == '301631090201050201060201073109020101020102020103'O)and(enc_CER_PDU(myValue) == '308031800201050201060201070000318002010102010202010300000000'O)) {setverdict(pass);} else {setverdict(fail);}
28209 Overall verdict: pass
28215 .*---------------------------------------------------------------------*
28216 :h3.CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN
28217 .*---------------------------------------------------------------------*
28220 <TC - CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN>
28229 BERPDU ::= [0] SEQUENCE OF BOOLEAN
28237 import from TempA all;
28238 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
28239 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
28241 const BERPDU myValue := {true, false }
28248 if ((enc_DER_PDU(myValue) == 'A00830060101FF010100'O)and(enc_CER_PDU(myValue) == 'A08030800101FF01010000000000'O)) {setverdict(pass);} else {setverdict(fail);}
28252 Overall verdict: pass
28258 .*---------------------------------------------------------------------*
28259 :h3.CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING
28260 .*---------------------------------------------------------------------*
28263 <TC - CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING>
28277 BERPDU ::= [0] SEQUENCE OF BOOLEAN
28285 import from TempA all;
28286 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
28287 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
28289 const BERPDU myValue := {true, false }
28296 if ((enc_DER_PDU(myValue) == 'A00830060101FF010100'O)and(enc_CER_PDU(myValue) == 'A08030800101FF01010000000000'O)) {setverdict(pass);} else {setverdict(fail);}
28300 Overall verdict: pass
28306 .*---------------------------------------------------------------------*
28307 :h3.CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING
28308 .*---------------------------------------------------------------------*
28311 <TC - CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING>
28325 BERPDU ::= [0] SEQUENCE OF BOOLEAN
28333 import from TempA all;
28334 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
28335 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
28337 const BERPDU myValue := {true, false }
28344 if ((enc_DER_PDU(myValue) == 'A0060101FF010100'O)and(enc_CER_PDU(myValue) == 'A0800101FF0101000000'O)) {setverdict(pass);} else {setverdict(fail);}
28348 Overall verdict: pass
28354 .*---------------------------------------------------------------------*
28355 :h3. DECODING DER, SEQUENCE OF INTEGER (empty)
28356 .*---------------------------------------------------------------------*
28359 <TC - DECODING DER, SEQUENCE OF INTEGER (empty)>
28368 BERPDU ::= SEQUENCE OF INTEGER
28374 import from TempA all;
28376 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28378 const BERPDU myValue := { }
28383 if (dec_BER_PDU('3000'O) == myValue)
28385 {setverdict(pass);} else {setverdict(fail);}
28390 Overall verdict: pass
28396 .*---------------------------------------------------------------------*
28397 :h3. DECODING CER, SEQUENCE OF INTEGER (empty)
28398 .*---------------------------------------------------------------------*
28401 <TC - DECODING CER, SEQUENCE OF INTEGER (empty)>
28410 BERPDU ::= SEQUENCE OF INTEGER
28416 import from TempA all;
28418 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28420 const BERPDU myValue := { }
28425 if (dec_BER_PDU('30800000'O) == myValue)
28427 {setverdict(pass);} else {setverdict(fail);}
28432 Overall verdict: pass
28438 .*---------------------------------------------------------------------*
28439 :h3. DECODING DER, SEQUENCE OF BOOLEAN
28440 .*---------------------------------------------------------------------*
28443 <TC - DECODING DER, SEQUENCE OF BOOLEAN>
28452 BERPDU ::= SEQUENCE OF BOOLEAN
28458 import from TempA all;
28460 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28462 const BERPDU myValue := {true, false }
28467 if (dec_BER_PDU('30060101FF010100'O) == myValue)
28469 {setverdict(pass);} else {setverdict(fail);}
28474 Overall verdict: pass
28480 .*---------------------------------------------------------------------*
28481 :h3. DECODING CER, SEQUENCE OF BOOLEAN
28482 .*---------------------------------------------------------------------*
28485 <TC - DECODING CER, SEQUENCE OF BOOLEAN>
28494 BERPDU ::= SEQUENCE OF BOOLEAN
28500 import from TempA all;
28502 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28504 const BERPDU myValue := {true, false }
28509 if (dec_BER_PDU('30800101FF0101000000'O) == myValue)
28511 {setverdict(pass);} else {setverdict(fail);}
28516 Overall verdict: pass
28522 .*---------------------------------------------------------------------*
28523 :h3. DECODING DER,SEQUENCE OF OCTET STRING
28524 .*---------------------------------------------------------------------*
28527 <TC - DECODING DER,SEQUENCE OF OCTET STRING >
28536 BERPDU ::= SEQUENCE OF OCTET STRING
28542 import from TempA all;
28544 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28546 const BERPDU myValue := {'FFFF'O, 'AB'O };
28551 if (dec_BER_PDU('30070402FFFF0401AB'O) == myValue)
28553 {setverdict(pass);} else {setverdict(fail);}
28558 Overall verdict: pass
28564 .*---------------------------------------------------------------------*
28565 :h3. DECODING CER,SEQUENCE OF OCTET STRING
28566 .*---------------------------------------------------------------------*
28569 <TC - DECODING CER,SEQUENCE OF OCTET STRING >
28578 BERPDU ::= SEQUENCE OF OCTET STRING
28584 import from TempA all;
28586 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28588 const BERPDU myValue := {'FFFF'O, 'AB'O };
28593 if (dec_BER_PDU('30800402FFFF0401AB0000'O) == myValue)
28595 {setverdict(pass);} else {setverdict(fail);}
28600 Overall verdict: pass
28606 .*---------------------------------------------------------------------*
28607 :h3. DECODING DER,SEQUENCE OF SEQUENCE
28608 .*---------------------------------------------------------------------*
28611 <TC - DECODING DER,SEQUENCE OF SEQUENCE >
28620 BERPDU ::= SEQUENCE OF SEQUENCE {a INTEGER, b BOOLEAN}
28626 import from TempA all;
28628 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28630 const BERPDU myValue := {
28646 if (dec_BER_PDU('301030060201050101FF3006020103010100'O) == myValue)
28648 {setverdict(pass);} else {setverdict(fail);}
28653 Overall verdict: pass
28659 .*---------------------------------------------------------------------*
28660 :h3. DECODING CER,SEQUENCE OF SEQUENCE
28661 .*---------------------------------------------------------------------*
28664 <TC - DECODING CER,SEQUENCE OF SEQUENCE >
28673 BERPDU ::= SEQUENCE OF SEQUENCE {a INTEGER, b BOOLEAN}
28679 import from TempA all;
28681 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28683 const BERPDU myValue := {
28699 if (dec_BER_PDU('308030800201050101FF0000308002010301010000000000'O) == myValue)
28701 {setverdict(pass);} else {setverdict(fail);}
28706 Overall verdict: pass
28712 .*---------------------------------------------------------------------*
28713 :h3. DECODING DER,SEQUENCE OF SET
28714 .*---------------------------------------------------------------------*
28717 <TC - DECODING DER,SEQUENCE OF SET >
28726 BERPDU ::= SEQUENCE OF SET {a INTEGER, b BOOLEAN}
28732 import from TempA all;
28734 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28736 const BERPDU myValue := {
28752 if (dec_BER_PDU('301031060101FF0201053106010100020103'O) == myValue)
28754 {setverdict(pass);} else {setverdict(fail);}
28759 Overall verdict: pass
28765 .*---------------------------------------------------------------------*
28766 :h3. DECODING CER,SEQUENCE OF SET
28767 .*---------------------------------------------------------------------*
28770 <TC - DECODING CER,SEQUENCE OF SET >
28779 BERPDU ::= SEQUENCE OF SET {a INTEGER, b BOOLEAN}
28785 import from TempA all;
28787 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28789 const BERPDU myValue := {
28805 if (dec_BER_PDU('308031800101FF0201050000318001010002010300000000'O) == myValue)
28807 {setverdict(pass);} else {setverdict(fail);}
28812 Overall verdict: pass
28818 .*---------------------------------------------------------------------*
28819 :h3. DECODING DER,SEQUENCE OF CHOICE
28820 .*---------------------------------------------------------------------*
28823 <TC - DECODING DER,SEQUENCE OF CHOICE >
28832 BERPDU ::= SEQUENCE OF CHOICE{a INTEGER, b BOOLEAN}
28838 import from TempA all;
28840 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28842 const BERPDU myValue := {
28856 if (dec_BER_PDU('3006020105010100'O) == myValue)
28858 {setverdict(pass);} else {setverdict(fail);}
28863 Overall verdict: pass
28869 .*---------------------------------------------------------------------*
28870 :h3. DECODING CER,SEQUENCE OF CHOICE
28871 .*---------------------------------------------------------------------*
28874 <TC - DECODING CER,SEQUENCE OF CHOICE >
28883 BERPDU ::= SEQUENCE OF CHOICE{a INTEGER, b BOOLEAN}
28889 import from TempA all;
28891 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28893 const BERPDU myValue := {
28907 if (dec_BER_PDU('30800201050101000000'O) == myValue)
28909 {setverdict(pass);} else {setverdict(fail);}
28914 Overall verdict: pass
28920 .*---------------------------------------------------------------------*
28921 :h3. DECODING DER,SEQUENCE OF SEQUENCE OF
28922 .*---------------------------------------------------------------------*
28925 <TC - DECODING DER,SEQUENCE OF SEQUENCE OF>
28934 BERPDU ::= SEQUENCE OF SEQUENCE OF INTEGER
28940 import from TempA all;
28942 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28944 const BERPDU myValue := {
28961 if (dec_BER_PDU('301630090201050201060201073009020101020102020103'O) == myValue)
28963 {setverdict(pass);} else {setverdict(fail);}
28968 Overall verdict: pass
28974 .*---------------------------------------------------------------------*
28975 :h3. DECODING CER,SEQUENCE OF SEQUENCE OF
28976 .*---------------------------------------------------------------------*
28979 <TC - DECODING CER,SEQUENCE OF SEQUENCE OF>
28988 BERPDU ::= SEQUENCE OF SEQUENCE OF INTEGER
28994 import from TempA all;
28996 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
28998 const BERPDU myValue := {
29015 if (dec_BER_PDU('308030800201050201060201070000308002010102010202010300000000'O) == myValue)
29017 {setverdict(pass);} else {setverdict(fail);}
29022 Overall verdict: pass
29028 .*---------------------------------------------------------------------*
29029 :h3. DECODING DER,SEQUENCE OF SET OF
29030 .*---------------------------------------------------------------------*
29033 <TC - DECODING DER,SEQUENCE OF SET OF>
29042 BERPDU ::= SEQUENCE OF SET OF INTEGER
29048 import from TempA all;
29050 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29052 const BERPDU myValue := {
29069 if (dec_BER_PDU('301631090201050201060201073109020101020102020103'O) == myValue)
29071 {setverdict(pass);} else {setverdict(fail);}
29076 Overall verdict: pass
29082 .*---------------------------------------------------------------------*
29083 :h3. DECODING CER,SEQUENCE OF SET OF
29084 .*---------------------------------------------------------------------*
29087 <TC - DECODING CER,SEQUENCE OF SET OF>
29096 BERPDU ::= SEQUENCE OF SET OF INTEGER
29102 import from TempA all;
29104 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29106 const BERPDU myValue := {
29123 if (dec_BER_PDU('308031800201050201060201070000318002010102010202010300000000'O) == myValue)
29125 {setverdict(pass);} else {setverdict(fail);}
29130 Overall verdict: pass
29136 .*---------------------------------------------------------------------*
29137 :h3. DECODING DER,TAGGED SEQUENCE OF BOOLEAN
29138 .*---------------------------------------------------------------------*
29141 <TC - DECODING DER,TAGGED SEQUENCE OF BOOLEAN>
29150 BERPDU ::= [0] SEQUENCE OF BOOLEAN
29156 import from TempA all;
29158 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29160 const BERPDU myValue := {true, false }
29165 if (dec_BER_PDU('A00830060101FF010100'O) == myValue)
29167 {setverdict(pass);} else {setverdict(fail);}
29172 Overall verdict: pass
29178 .*---------------------------------------------------------------------*
29179 :h3. DECODING CER,TAGGED SEQUENCE OF BOOLEAN
29180 .*---------------------------------------------------------------------*
29183 <TC - DECODING CER,TAGGED SEQUENCE OF BOOLEAN>
29192 BERPDU ::= [0] SEQUENCE OF BOOLEAN
29198 import from TempA all;
29200 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29202 const BERPDU myValue := {true, false }
29207 if (dec_BER_PDU('A08030800101FF01010000000000'O) == myValue)
29209 {setverdict(pass);} else {setverdict(fail);}
29214 Overall verdict: pass
29220 .*---------------------------------------------------------------------*
29221 :h3. DECODING DER,TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING
29222 .*---------------------------------------------------------------------*
29225 <TC - DECODING DER,TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING>
29238 BERPDU ::= [0] SEQUENCE OF BOOLEAN
29244 import from TempA all;
29246 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29248 const BERPDU myValue := {true, false }
29253 if (dec_BER_PDU('A00830060101FF010100'O) == myValue)
29255 {setverdict(pass);} else {setverdict(fail);}
29260 Overall verdict: pass
29266 .*---------------------------------------------------------------------*
29267 :h3. DECODING CER,TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING
29268 .*---------------------------------------------------------------------*
29271 <TC - DECODING CER,TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING>
29284 BERPDU ::= [0] SEQUENCE OF BOOLEAN
29290 import from TempA all;
29292 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29294 const BERPDU myValue := {true, false }
29299 if (dec_BER_PDU('A08030800101FF01010000000000'O) == myValue)
29301 {setverdict(pass);} else {setverdict(fail);}
29306 Overall verdict: pass
29312 .*---------------------------------------------------------------------*
29313 :h3. DECODING DER,TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING
29314 .*---------------------------------------------------------------------*
29317 <TC - DECODING DER,TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING>
29330 BERPDU ::= [0] SEQUENCE OF BOOLEAN
29336 import from TempA all;
29338 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29340 const BERPDU myValue := {true, false }
29345 if (dec_BER_PDU('A0060101FF010100'O) == myValue)
29347 {setverdict(pass);} else {setverdict(fail);}
29352 Overall verdict: pass
29358 .*---------------------------------------------------------------------*
29359 :h3. DECODING CER,TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING
29360 .*---------------------------------------------------------------------*
29363 <TC - DECODING CER,TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING>
29376 BERPDU ::= [0] SEQUENCE OF BOOLEAN
29382 import from TempA all;
29384 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
29386 const BERPDU myValue := {true, false }
29391 if (dec_BER_PDU('A0800101FF0101000000'O) == myValue)
29393 {setverdict(pass);} else {setverdict(fail);}
29398 Overall verdict: pass
29404 .*---------------------------------------------------------------------*
29405 :h3.CER + DER encoding of SET (EMPTY)
29406 .*---------------------------------------------------------------------*
29409 <TC - CER + DER encoding of SET (EMPTY)>
29420 b BOOLEAN OPTIONAL,
29429 import from TempA all;
29430 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29431 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29433 const BERPDU myValue := {b := omit,
29441 if ((enc_DER_PDU(myValue) == '3100'O)and(enc_CER_PDU(myValue) == '31800000'O)) {setverdict(pass);} else {setverdict(fail);}
29445 Overall verdict: pass
29451 .*---------------------------------------------------------------------*
29452 :h3.CER + DER encoding of SET (only one element is used)
29453 .*---------------------------------------------------------------------*
29456 <TC - CER + DER encoding of SET (only one element is used)>
29467 b BOOLEAN OPTIONAL,
29476 import from TempA all;
29477 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29478 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29480 const BERPDU myValue := {b := true,
29488 if ((enc_DER_PDU(myValue) == '31030101FF'O)and(enc_CER_PDU(myValue) == '31800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
29492 Overall verdict: pass
29498 .*---------------------------------------------------------------------*
29499 :h3.CER + DER encoding of SET (both elements are used)
29500 .*---------------------------------------------------------------------*
29503 <TC - CER + DER encoding of SET (both elements are used)>
29514 b BOOLEAN OPTIONAL,
29523 import from TempA all;
29524 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29525 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29527 const BERPDU myValue := {b := true,
29535 if ((enc_DER_PDU(myValue) == '31060101FF020105'O)and(enc_CER_PDU(myValue) == '31800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29539 Overall verdict: pass
29545 .*---------------------------------------------------------------------*
29546 :h3. encoding of SET(different order) (both elements are used)
29547 .*---------------------------------------------------------------------*
29550 <TC - encoding of SET(different order) (both elements are used)>
29561 b BOOLEAN OPTIONAL,
29570 import from TempA all;
29571 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29572 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29574 const BERPDU myValue := { c := 5,
29582 if ((enc_DER_PDU(myValue) == '31060101FF020105'O)and(enc_CER_PDU(myValue) == '31800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29586 Overall verdict: pass
29592 .*---------------------------------------------------------------------*
29593 :h3.CER + DER encoding of SET (different order2)(both elements are used)
29594 .*---------------------------------------------------------------------*
29597 <TC - CER + DER encoding of SET (different order2)(both elements are used)>
29609 c INTEGER OPTIONAL,
29618 import from TempA all;
29619 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29620 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29622 const BERPDU myValue := {b := true,
29630 if ((enc_DER_PDU(myValue) == '31060101FF020105'O)and(enc_CER_PDU(myValue) == '31800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29634 Overall verdict: pass
29640 .*---------------------------------------------------------------------*
29641 :h3.CER + DER encoding of SET (one element is equal to Default)
29642 .*---------------------------------------------------------------------*
29645 <TC - CER + DER encoding of SET (one element is equal to Default)>
29656 b BOOLEAN DEFAULT TRUE,
29665 import from TempA all;
29666 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29667 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29669 const BERPDU myValue := {b := true,
29677 if ((enc_DER_PDU(myValue) == '3103020105'O)and(enc_CER_PDU(myValue) == '31800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29681 Overall verdict: pass
29687 .*---------------------------------------------------------------------*
29688 :h3. encoding of SET (different order)(one element is equal to Default)
29689 .*---------------------------------------------------------------------*
29692 <TC - encoding of SET (different order)(one element is equal to Default)>
29703 b BOOLEAN DEFAULT TRUE,
29712 import from TempA all;
29713 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29714 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29716 const BERPDU myValue := {
29725 if ((enc_DER_PDU(myValue) == '3103020105'O)and(enc_CER_PDU(myValue) == '31800201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29729 Overall verdict: pass
29735 .*---------------------------------------------------------------------*
29736 :h3.CER + DER encoding of SET (one element is not equal to Default)
29737 .*---------------------------------------------------------------------*
29740 <TC - CER + DER encoding of SET (one element is not equal to Default)>
29751 b BOOLEAN DEFAULT TRUE,
29760 import from TempA all;
29761 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29762 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29764 const BERPDU myValue := {b := false,
29772 if ((enc_DER_PDU(myValue) == '3106010100020105'O)and(enc_CER_PDU(myValue) == '31800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29776 Overall verdict: pass
29782 .*---------------------------------------------------------------------*
29783 :h3. encoding of SET (different order) (one element is not equal to Default)
29784 .*---------------------------------------------------------------------*
29787 <TC - encoding of SET (different order) (one element is not equal to Default)>
29798 b BOOLEAN DEFAULT TRUE,
29807 import from TempA all;
29808 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29809 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29811 const BERPDU myValue := {
29820 if ((enc_DER_PDU(myValue) == '3106010100020105'O)and(enc_CER_PDU(myValue) == '31800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29824 Overall verdict: pass
29830 .*---------------------------------------------------------------------*
29831 :h3. encoding of SET (different order2) (one element is not equal to Default)
29832 .*---------------------------------------------------------------------*
29835 <TC - encoding of SET (different order2) (one element is not equal to Default)>
29847 c INTEGER OPTIONAL,
29848 b BOOLEAN DEFAULT TRUE
29856 import from TempA all;
29857 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29858 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29860 const BERPDU myValue := {
29869 if ((enc_DER_PDU(myValue) == '3106010100020105'O)and(enc_CER_PDU(myValue) == '31800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);}
29873 Overall verdict: pass
29879 .*---------------------------------------------------------------------*
29880 :h3.CER + DER encoding of SET (EMPTY), AUTOMATIC TAGGING
29881 .*---------------------------------------------------------------------*
29884 <TC - CER + DER encoding of SET (EMPTY), AUTOMATIC TAGGING>
29900 b BOOLEAN OPTIONAL,
29909 import from TempA all;
29910 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29911 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29913 const BERPDU myValue := {b := omit,
29921 if ((enc_DER_PDU(myValue) == '3100'O)and(enc_CER_PDU(myValue) == '31800000'O)) {setverdict(pass);} else {setverdict(fail);}
29925 Overall verdict: pass
29931 .*---------------------------------------------------------------------*
29932 :h3.CER + DER encoding of SET(only one element is used) AUTOMATIC TAGGING
29933 .*---------------------------------------------------------------------*
29936 <TC - CER + DER encoding of SET(only one element is used) AUTOMATIC TAGGING>
29952 b BOOLEAN OPTIONAL,
29961 import from TempA all;
29962 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
29963 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
29965 const BERPDU myValue := {b := true,
29973 if ((enc_DER_PDU(myValue) == '31038001FF'O)and(enc_CER_PDU(myValue) == '31808001FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
29977 Overall verdict: pass
29983 .*---------------------------------------------------------------------*
29984 :h3. encoding of SET (different order)(only one element is used) AUTOMATIC TAGGING
29985 .*---------------------------------------------------------------------*
29988 <TC - encoding of SET (different order)(only one element is used) AUTOMATIC TAGGING>
30004 b BOOLEAN OPTIONAL,
30013 import from TempA all;
30014 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30015 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30017 const BERPDU myValue := {
30026 if ((enc_DER_PDU(myValue) == '31038001FF'O)and(enc_CER_PDU(myValue) == '31808001FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
30030 Overall verdict: pass
30036 .*---------------------------------------------------------------------*
30037 :h3.CER + DER encoding of SET (both elements are used) AUTOMATIC TAGGING
30038 .*---------------------------------------------------------------------*
30041 <TC - CER + DER encoding of SET (both elements are used) AUTOMATIC TAGGING>
30057 b BOOLEAN OPTIONAL,
30066 import from TempA all;
30067 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30068 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30070 const BERPDU myValue := {b := true,
30078 if ((enc_DER_PDU(myValue) == '31068001FF810105'O)and(enc_CER_PDU(myValue) == '31808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
30082 Overall verdict: pass
30088 .*---------------------------------------------------------------------*
30089 :h3.encoding of SET (both elements are used)(different order) AUTOMATIC TAGGING
30090 .*---------------------------------------------------------------------*
30093 <TC - encoding of SET (both elements are used)(different order) AUTOMATIC TAGGING>
30109 b BOOLEAN OPTIONAL,
30118 import from TempA all;
30119 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30120 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30122 const BERPDU myValue := {
30131 if ((enc_DER_PDU(myValue) == '31068001FF810105'O)and(enc_CER_PDU(myValue) == '31808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
30135 Overall verdict: pass
30141 .*---------------------------------------------------------------------*
30142 :h3.CER + DER encoding of SET (both elements are used)(different order2) AUTOMATIC TAGGING
30143 .*---------------------------------------------------------------------*
30146 <TC - CER + DER encoding of SET (both elements are used)(different order2) AUTOMATIC TAGGING>
30163 c INTEGER OPTIONAL,
30172 import from TempA all;
30173 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30174 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30176 const BERPDU myValue := {b := true,
30184 if ((enc_DER_PDU(myValue) == '31068001058101FF'O)and(enc_CER_PDU(myValue) == '31808001058101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
30188 Overall verdict: pass
30194 .*---------------------------------------------------------------------*
30195 :h3.CER + DER encoding of SET (one element is equal to Default) AUTOMATIC TAGGING
30196 .*---------------------------------------------------------------------*
30199 <TC - CER + DER encoding of SET (one element is equal to Default) AUTOMATIC TAGGING>
30215 b BOOLEAN DEFAULT TRUE,
30224 import from TempA all;
30225 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30226 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30228 const BERPDU myValue := {b := true,
30236 if ((enc_DER_PDU(myValue) == '3103810105'O)and(enc_CER_PDU(myValue) == '31808101050000'O)) {setverdict(pass);} else {setverdict(fail);}
30240 Overall verdict: pass
30246 .*---------------------------------------------------------------------*
30247 :h3. encoding of SET (different order) (one element is equal to Default) AUTOMATIC TAGGING
30248 .*---------------------------------------------------------------------*
30251 <TC - encoding of SET (different order) (one element is equal to Default) AUTOMATIC TAGGING>
30267 b BOOLEAN DEFAULT TRUE,
30276 import from TempA all;
30277 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30278 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30280 const BERPDU myValue := {
30289 if ((enc_DER_PDU(myValue) == '3103810105'O)and(enc_CER_PDU(myValue) == '31808101050000'O)) {setverdict(pass);} else {setverdict(fail);}
30293 Overall verdict: pass
30299 .*---------------------------------------------------------------------*
30300 :h3.CER + DER encoding of SET (one element is not equal to Default) AUTOMATIC TAGGING
30301 .*---------------------------------------------------------------------*
30304 <TC - CER + DER encoding of SET (one element is not equal to Default) AUTOMATIC TAGGING>
30320 b BOOLEAN DEFAULT TRUE,
30329 import from TempA all;
30330 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30331 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30333 const BERPDU myValue := {b := false,
30341 if ((enc_DER_PDU(myValue) == '3106800100810105'O)and(enc_CER_PDU(myValue) == '31808001008101050000'O)) {setverdict(pass);} else {setverdict(fail);}
30345 Overall verdict: pass
30351 .*---------------------------------------------------------------------*
30352 :h3. encoding of SET (different order)(one element is not equal to Default) AUTOMATIC TAGGING
30353 .*---------------------------------------------------------------------*
30356 <TC - encoding of SET (different order)(one element is not equal to Default) AUTOMATIC TAGGING>
30372 b BOOLEAN DEFAULT TRUE,
30381 import from TempA all;
30382 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30383 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30385 const BERPDU myValue := {
30394 if ((enc_DER_PDU(myValue) == '3106800100810105'O)and(enc_CER_PDU(myValue) == '31808001008101050000'O)) {setverdict(pass);} else {setverdict(fail);}
30398 Overall verdict: pass
30404 .*---------------------------------------------------------------------*
30405 :h3.CER + DER encoding of SET (different order2)(one element is not equal to Default) AUTOMATIC TAGGING
30406 .*---------------------------------------------------------------------*
30409 <TC - CER + DER encoding of SET (different order2)(one element is not equal to Default) AUTOMATIC TAGGING>
30426 c INTEGER OPTIONAL,
30427 b BOOLEAN DEFAULT TRUE
30435 import from TempA all;
30436 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30437 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30439 const BERPDU myValue := {b := false,
30447 if ((enc_DER_PDU(myValue) == '3106800105810100'O)and(enc_CER_PDU(myValue) == '31808001058101000000'O)) {setverdict(pass);} else {setverdict(fail);}
30451 Overall verdict: pass
30457 .*---------------------------------------------------------------------*
30458 :h3.CER + DER encoding of SET (both elements are used) IMPLICIT TAGS for elements
30459 .*---------------------------------------------------------------------*
30462 <TC - CER + DER encoding of SET (both elements are used) IMPLICIT TAGS for elements>
30473 b [30] IMPLICIT BOOLEAN OPTIONAL,
30474 c [31] IMPLICIT INTEGER OPTIONAL
30482 import from TempA all;
30483 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30484 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30486 const BERPDU myValue := {b := true,
30494 if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
30498 Overall verdict: pass
30504 .*---------------------------------------------------------------------*
30505 :h3. encoding of SET (different order) (both elements are used) IMPLICIT TAGS for elements
30506 .*---------------------------------------------------------------------*
30509 <TC - encoding of SET (different order) (both elements are used) IMPLICIT TAGS for elements>
30520 b [30] IMPLICIT BOOLEAN OPTIONAL,
30521 c [31] IMPLICIT INTEGER OPTIONAL
30529 import from TempA all;
30530 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30531 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30533 const BERPDU myValue := {
30542 if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
30546 Overall verdict: pass
30552 .*---------------------------------------------------------------------*
30553 :h3.CER + DER encoding of SET (different order2) (both elements are used) IMPLICIT TAGS for elements
30554 .*---------------------------------------------------------------------*
30557 <TC - CER + DER encoding of SET (different order2) (both elements are used) IMPLICIT TAGS for elements>
30568 c [31] IMPLICIT INTEGER OPTIONAL,
30569 b [30] IMPLICIT BOOLEAN OPTIONAL
30577 import from TempA all;
30578 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30579 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30581 const BERPDU myValue := {b := true,
30589 if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
30593 Overall verdict: pass
30599 .*---------------------------------------------------------------------*
30600 :h3.CER + DER encoding of SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
30601 .*---------------------------------------------------------------------*
30604 <TC - CER + DER encoding of SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
30620 b [30] IMPLICIT BOOLEAN OPTIONAL,
30621 c [31] IMPLICIT INTEGER OPTIONAL
30629 import from TempA all;
30630 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30631 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30633 const BERPDU myValue := {b := true,
30641 if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
30645 Overall verdict: pass
30651 .*---------------------------------------------------------------------*
30652 :h3.encoding of SET (different order) (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
30653 .*---------------------------------------------------------------------*
30656 <TC - encoding of SET (different order) (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
30672 b [30] IMPLICIT BOOLEAN OPTIONAL,
30673 c [31] IMPLICIT INTEGER OPTIONAL
30681 import from TempA all;
30682 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30683 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30685 const BERPDU myValue := {
30694 if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
30698 Overall verdict: pass
30704 .*---------------------------------------------------------------------*
30705 :h3.CER + DER encoding of SET (different order2)(both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
30706 .*---------------------------------------------------------------------*
30709 <TC - CER + DER encoding of SET (different order2)(both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
30725 c [31] IMPLICIT INTEGER OPTIONAL,
30726 b [30] IMPLICIT BOOLEAN OPTIONAL
30735 import from TempA all;
30736 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30737 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30739 const BERPDU myValue := {b := true,
30747 if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);}
30751 Overall verdict: pass
30757 .*---------------------------------------------------------------------*
30758 :h3.CER + DER encoding of SET (both elements are used) EXPLICIT TAGS for elements
30759 .*---------------------------------------------------------------------*
30762 <TC - CER + DER encoding of SET (both elements are used) EXPLICIT TAGS for elements>
30773 b [30] EXPLICIT BOOLEAN OPTIONAL,
30774 c [31] EXPLICIT INTEGER OPTIONAL
30782 import from TempA all;
30783 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30784 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30786 const BERPDU myValue := {b := true,
30794 if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
30798 Overall verdict: pass
30804 .*---------------------------------------------------------------------*
30805 :h3. encoding of SET (different order)(both elements are used) EXPLICIT TAGS for elements
30806 .*---------------------------------------------------------------------*
30809 <TC - encoding of SET (different order)(both elements are used) EXPLICIT TAGS for elements>
30820 b [30] EXPLICIT BOOLEAN OPTIONAL,
30821 c [31] EXPLICIT INTEGER OPTIONAL
30829 import from TempA all;
30830 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30831 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30833 const BERPDU myValue := {
30842 if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
30846 Overall verdict: pass
30852 .*---------------------------------------------------------------------*
30853 :h3.CER + DER encoding of SET (different order2) (both elements are used) EXPLICIT TAGS for elements
30854 .*---------------------------------------------------------------------*
30857 <TC - CER + DER encoding of SET (different order2) (both elements are used) EXPLICIT TAGS for elements>
30869 c [31] EXPLICIT INTEGER OPTIONAL,
30870 b [30] EXPLICIT BOOLEAN OPTIONAL
30878 import from TempA all;
30879 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30880 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30882 const BERPDU myValue := {b := true,
30890 if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
30894 Overall verdict: pass
30900 .*---------------------------------------------------------------------*
30901 :h3.CER + DER encoding of SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
30902 .*---------------------------------------------------------------------*
30905 <TC - CER + DER encoding of SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
30921 b [30] EXPLICIT BOOLEAN OPTIONAL,
30922 c [31] EXPLICIT INTEGER OPTIONAL
30930 import from TempA all;
30931 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30932 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30934 const BERPDU myValue := {b := true,
30942 if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
30946 Overall verdict: pass
30952 .*---------------------------------------------------------------------*
30953 :h3. encoding of SET (different order) (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
30954 .*---------------------------------------------------------------------*
30957 <TC - encoding of SET (different order) (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
30973 b [30] EXPLICIT BOOLEAN OPTIONAL,
30974 c [31] EXPLICIT INTEGER OPTIONAL
30982 import from TempA all;
30983 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
30984 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
30986 const BERPDU myValue := {
30995 if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
30999 Overall verdict: pass
31005 .*---------------------------------------------------------------------*
31006 :h3.CER + DER encoding of SET (different order2)(both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
31007 .*---------------------------------------------------------------------*
31010 <TC - CER + DER encoding of SET (different order2)(both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
31026 c [31] EXPLICIT INTEGER OPTIONAL,
31027 b [30] EXPLICIT BOOLEAN OPTIONAL
31036 import from TempA all;
31037 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31038 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31040 const BERPDU myValue := {b := true,
31048 if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
31052 Overall verdict: pass
31058 .*---------------------------------------------------------------------*
31059 :h3.CER + DER encoding of TAGGED SET (both elements are used)
31060 .*---------------------------------------------------------------------*
31063 <TC - CER + DER encoding of TAGGED SET (both elements are used)>
31074 b BOOLEAN OPTIONAL,
31083 import from TempA all;
31084 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31085 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31087 const BERPDU myValue := {b := true,
31095 if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
31099 Overall verdict: pass
31105 .*---------------------------------------------------------------------*
31106 :h3. encoding of TAGGED SET (different order) (both elements are used)
31107 .*---------------------------------------------------------------------*
31110 <TC - encoding of TAGGED SET (different order) (both elements are used)>
31121 b BOOLEAN OPTIONAL,
31130 import from TempA all;
31131 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31132 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31134 const BERPDU myValue := {
31143 if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
31147 Overall verdict: pass
31153 .*---------------------------------------------------------------------*
31154 :h3.CER + DER encoding of TAGGED SET (different order2) (both elements are used)
31155 .*---------------------------------------------------------------------*
31158 <TC - CER + DER encoding of TAGGED SET (different order2) (both elements are used)>
31170 c INTEGER OPTIONAL,
31179 import from TempA all;
31180 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31181 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31183 const BERPDU myValue := {b := true,
31191 if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
31195 Overall verdict: pass
31201 .*---------------------------------------------------------------------*
31202 :h3.CER + DER encoding of TAGGED SET (both elements are used), AUTOMATIC TAGGING ENVIRONMENT
31203 .*---------------------------------------------------------------------*
31206 <TC - CER + DER encoding of TAGGED SET (both elements are used), AUTOMATIC TAGGING ENVIRONMENT>
31222 b BOOLEAN OPTIONAL,
31231 import from TempA all;
31232 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31233 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31235 const BERPDU myValue := {b := true,
31243 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
31247 Overall verdict: pass
31253 .*---------------------------------------------------------------------*
31254 :h3. encoding of TAGGED SET (different order) (both elements are used), AUTOMATIC TAGGING ENVIRONMENT
31255 .*---------------------------------------------------------------------*
31258 <TC - encoding of TAGGED SET (different order) (both elements are used), AUTOMATIC TAGGING ENVIRONMENT>
31274 b BOOLEAN OPTIONAL,
31283 import from TempA all;
31284 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31285 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31287 const BERPDU myValue := {
31296 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
31300 Overall verdict: pass
31306 .*---------------------------------------------------------------------*
31307 :h3.CER + DER encoding of TAGGED SET (different order2) (both elements are used), AUTOMATIC TAGGING ENVIRONMENT
31308 .*---------------------------------------------------------------------*
31311 <TC - CER + DER encoding of TAGGED SET (different order2) (both elements are used), AUTOMATIC TAGGING ENVIRONMENT>
31327 c INTEGER OPTIONAL,
31336 import from TempA all;
31337 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31338 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31340 const BERPDU myValue := {b := true,
31348 if ((enc_DER_PDU(myValue) == 'A0068001058101FF'O)and(enc_CER_PDU(myValue) == 'A0808001058101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
31352 Overall verdict: pass
31358 .*---------------------------------------------------------------------*
31359 :h3.CER + DER encoding of TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT
31360 .*---------------------------------------------------------------------*
31363 <TC - CER + DER encoding of TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
31379 b BOOLEAN OPTIONAL,
31388 import from TempA all;
31389 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31390 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31392 const BERPDU myValue := {b := true,
31400 if ((enc_DER_PDU(myValue) == 'A0060101FF020105'O)and(enc_CER_PDU(myValue) == 'A0800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
31404 Overall verdict: pass
31410 .*---------------------------------------------------------------------*
31411 :h3. encoding of TAGGED SET (different order)(both elements are used), IMPLICIT TAGGING ENVIRONMENT
31412 .*---------------------------------------------------------------------*
31415 <TC - encoding of TAGGED SET (different order)(both elements are used), IMPLICIT TAGGING ENVIRONMENT>
31431 b BOOLEAN OPTIONAL,
31440 import from TempA all;
31441 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31442 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31444 const BERPDU myValue := {
31453 if ((enc_DER_PDU(myValue) == 'A0060101FF020105'O)and(enc_CER_PDU(myValue) == 'A0800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
31457 Overall verdict: pass
31463 .*---------------------------------------------------------------------*
31464 :h3.CER + DER encoding of TAGGED SET (different order2)(both elements are used), IMPLICIT TAGGING ENVIRONMENT
31465 .*---------------------------------------------------------------------*
31468 <TC - CER + DER encoding of TAGGED SET (different order2)(both elements are used), IMPLICIT TAGGING ENVIRONMENT>
31485 c INTEGER OPTIONAL,
31494 import from TempA all;
31495 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31496 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31498 const BERPDU myValue := {b := true,
31506 if ((enc_DER_PDU(myValue) == 'A0060101FF020105'O)and(enc_CER_PDU(myValue) == 'A0800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);}
31510 Overall verdict: pass
31516 .*---------------------------------------------------------------------*
31517 :h3.CER + DER encoding of TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT
31518 .*---------------------------------------------------------------------*
31521 <TC - CER + DER encoding of TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
31537 b BOOLEAN OPTIONAL,
31546 import from TempA all;
31547 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31548 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31550 const BERPDU myValue := {b := true,
31558 if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
31562 Overall verdict: pass
31568 .*---------------------------------------------------------------------*
31569 :h3. encoding of TAGGED SET (different order) (both elements are used), EXPLICIT TAGGING ENVIRONMENT
31570 .*---------------------------------------------------------------------*
31573 <TC - encoding of TAGGED SET (different order) (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
31589 b BOOLEAN OPTIONAL,
31598 import from TempA all;
31599 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31600 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31602 const BERPDU myValue := {
31611 if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
31615 Overall verdict: pass
31621 .*---------------------------------------------------------------------*
31622 :h3.CER + DER encoding of TAGGED SET (different order2) (both elements are used), EXPLICIT TAGGING ENVIRONMENT
31623 .*---------------------------------------------------------------------*
31626 <TC - CER + DER encoding of TAGGED SET (different order2) (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
31642 c INTEGER OPTIONAL,
31651 import from TempA all;
31652 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31653 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31655 const BERPDU myValue := {b := true,
31663 if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
31667 Overall verdict: pass
31673 .*---------------------------------------------------------------------*
31674 :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used)
31675 .*---------------------------------------------------------------------*
31678 <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used)>
31689 b [0] BOOLEAN OPTIONAL,
31690 c [1] INTEGER OPTIONAL
31698 import from TempA all;
31699 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31700 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31702 const BERPDU myValue := {b := true,
31710 if ((enc_DER_PDU(myValue) == 'A00C310AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803180A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
31714 Overall verdict: pass
31720 .*---------------------------------------------------------------------*
31721 :h3. encoding of TAGGED SET (both elements are TAGGED and used)
31722 .*---------------------------------------------------------------------*
31725 <TC - encoding of TAGGED SET (both elements are TAGGED and used)>
31736 b [0] BOOLEAN OPTIONAL,
31737 c [1] INTEGER OPTIONAL
31745 import from TempA all;
31746 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31747 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31749 const BERPDU myValue := {
31758 if ((enc_DER_PDU(myValue) == 'A00C310AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803180A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
31762 Overall verdict: pass
31768 .*---------------------------------------------------------------------*
31769 :h3.CER + DER encoding of TAGGED SET (different order) (both elements are TAGGED and used)
31770 .*---------------------------------------------------------------------*
31773 <TC - CER + DER encoding of TAGGED SET (different order) (both elements are TAGGED and used)>
31784 b [1] BOOLEAN OPTIONAL,
31785 c [0] INTEGER OPTIONAL
31793 import from TempA all;
31794 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31795 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31797 const BERPDU myValue := {b := true,
31805 if ((enc_DER_PDU(myValue) == 'A00C310AA003020105A1030101FF'O)and(enc_CER_PDU(myValue) == 'A0803180A0800201050000A1800101FF000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
31809 Overall verdict: pass
31815 .*---------------------------------------------------------------------*
31816 :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
31817 .*---------------------------------------------------------------------*
31820 <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
31836 b [0] BOOLEAN OPTIONAL,
31837 c [1] INTEGER OPTIONAL
31845 import from TempA all;
31846 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31847 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31849 const BERPDU myValue := {b := true,
31857 if ((enc_DER_PDU(myValue) == 'A00C310AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803180A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
31861 Overall verdict: pass
31867 .*---------------------------------------------------------------------*
31868 :h3. encoding of TAGGED SET (different order)(both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
31869 .*---------------------------------------------------------------------*
31872 <TC - encoding of TAGGED SET (different order)(both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
31888 b [0] BOOLEAN OPTIONAL,
31889 c [1] INTEGER OPTIONAL
31897 import from TempA all;
31898 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31899 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31901 const BERPDU myValue := {
31910 if ((enc_DER_PDU(myValue) == 'A00C310AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803180A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
31914 Overall verdict: pass
31920 .*---------------------------------------------------------------------*
31921 :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
31922 .*---------------------------------------------------------------------*
31925 <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
31941 b [1] BOOLEAN OPTIONAL,
31942 c [0] INTEGER OPTIONAL
31950 import from TempA all;
31951 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
31952 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
31954 const BERPDU myValue := {b := true,
31962 if ((enc_DER_PDU(myValue) == 'A00C310AA003020105A1030101FF'O)and(enc_CER_PDU(myValue) == 'A0803180A0800201050000A1800101FF000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
31966 Overall verdict: pass
31972 .*---------------------------------------------------------------------*
31973 :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
31974 .*---------------------------------------------------------------------*
31977 <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
31993 b [0] BOOLEAN OPTIONAL,
31994 c [1] INTEGER OPTIONAL
32002 import from TempA all;
32003 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32004 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32006 const BERPDU myValue := {b := true,
32014 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
32018 Overall verdict: pass
32024 .*---------------------------------------------------------------------*
32025 :h3. encoding of TAGGED SET (different order) (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
32026 .*---------------------------------------------------------------------*
32029 <TC - encoding of TAGGED SET (different order) (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
32045 b [0] BOOLEAN OPTIONAL,
32046 c [1] INTEGER OPTIONAL
32054 import from TempA all;
32055 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32056 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32058 const BERPDU myValue := {
32067 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
32071 Overall verdict: pass
32077 .*---------------------------------------------------------------------*
32078 :h3.CER + DER encoding of TAGGED SET (different order2)(both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
32079 .*---------------------------------------------------------------------*
32082 <TC - CER + DER encoding of TAGGED SET (different order2)(both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
32099 c [1] INTEGER OPTIONAL,
32100 b [0] BOOLEAN OPTIONAL
32108 import from TempA all;
32109 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32110 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32112 const BERPDU myValue := {b := true,
32120 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
32124 Overall verdict: pass
32130 .*---------------------------------------------------------------------*
32131 :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
32132 .*---------------------------------------------------------------------*
32135 <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
32151 b [0] BOOLEAN OPTIONAL,
32152 c [1] INTEGER OPTIONAL
32160 import from TempA all;
32161 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32162 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32164 const BERPDU myValue := {b := true,
32172 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
32177 Overall verdict: pass
32183 .*---------------------------------------------------------------------*
32184 :h3.encoding of TAGGED SET (different order) (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
32185 .*---------------------------------------------------------------------*
32188 <TC - encoding of TAGGED SET (different order) (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
32204 b [0] BOOLEAN OPTIONAL,
32205 c [1] INTEGER OPTIONAL
32213 import from TempA all;
32214 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32215 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32217 const BERPDU myValue := {
32226 if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);}
32231 Overall verdict: pass
32237 .*---------------------------------------------------------------------*
32238 :h3.CER + DER encoding of TAGGED SET (different order2) (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
32239 .*---------------------------------------------------------------------*
32242 <TC - CER + DER encoding of TAGGED SET (different order2) (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
32259 c [0] INTEGER OPTIONAL,
32260 b [1] BOOLEAN OPTIONAL
32268 import from TempA all;
32269 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32270 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32272 const BERPDU myValue := {b := true,
32280 if ((enc_DER_PDU(myValue) == 'A0068001058101FF'O)and(enc_CER_PDU(myValue) == 'A0808001058101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
32285 Overall verdict: pass
32291 .*---------------------------------------------------------------------*
32292 :h3.CER + DER encoding of SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
32293 .*---------------------------------------------------------------------*
32296 <TC - CER + DER encoding of SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
32312 b [5] BOOLEAN OPTIONAL,
32321 import from TempA all;
32322 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32323 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32325 const BERPDU myValue := {b := true,
32333 if ((enc_DER_PDU(myValue) == '31060201058501FF'O)and(enc_CER_PDU(myValue) == '31800201058501FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
32337 Overall verdict: pass
32343 .*---------------------------------------------------------------------*
32344 :h3. encoding of SET , (different order) one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
32345 .*---------------------------------------------------------------------*
32348 <TC - encoding of SET , (different order) one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
32364 b [5] BOOLEAN OPTIONAL,
32373 import from TempA all;
32374 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32375 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32377 const BERPDU myValue := { c := 5 ,
32385 if ((enc_DER_PDU(myValue) == '31060201058501FF'O)and(enc_CER_PDU(myValue) == '31800201058501FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
32389 Overall verdict: pass
32395 .*---------------------------------------------------------------------*
32396 :h3.CER + DER encoding of SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
32397 .*---------------------------------------------------------------------*
32400 <TC - CER + DER encoding of SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
32416 {x INTEGER OPTIONAL,
32423 b BOOLEAN OPTIONAL,
32424 c INTEGER OPTIONAL,
32425 COMPONENTS OF MySeq
32433 import from TempA all;
32434 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32435 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32437 const BERPDU myValue := {b := true,
32447 if ((enc_DER_PDU(myValue) == '310C8001FF8101058201068301FF'O)and(enc_CER_PDU(myValue) == '31808001FF8101058201068301FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
32451 Overall verdict: pass
32457 .*---------------------------------------------------------------------*
32458 :h3. encoding of SET (different order) ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
32459 .*---------------------------------------------------------------------*
32462 <TC - encoding of SET (different order) ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
32487 b BOOLEAN OPTIONAL,
32488 c INTEGER OPTIONAL,
32489 COMPONENTS OF MySeq
32497 import from TempA all;
32498 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32499 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32501 const BERPDU myValue := {b := true,
32511 if ((enc_DER_PDU(myValue) == '310C8001FF8101058201FF830106'O)and(enc_CER_PDU(myValue) == '31808001FF8101058201FF8301060000'O)) {setverdict(pass);} else {setverdict(fail);}
32515 Overall verdict: pass
32521 .*---------------------------------------------------------------------*
32522 :h3.CER + DER encoding of SET , one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
32523 .*---------------------------------------------------------------------*
32526 <TC - CER + DER encoding of SET , one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
32541 {x [0] INTEGER OPTIONAL,
32548 b BOOLEAN OPTIONAL,
32549 c INTEGER OPTIONAL,
32550 COMPONENTS OF MySeq
32558 import from TempA all;
32559 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32560 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32562 const BERPDU myValue := {b := true,
32572 if ((enc_DER_PDU(myValue) == '310C8001FF8101058201068301FF'O)and(enc_CER_PDU(myValue) == '31808001FF8101058201068301FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
32576 Overall verdict: pass
32582 .*---------------------------------------------------------------------*
32583 :h3.CER + DER encoding of SET , (different order) one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
32584 .*---------------------------------------------------------------------*
32587 <TC - CER + DER encoding of SET , (different order) one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
32604 x [0] INTEGER OPTIONAL
32611 b BOOLEAN OPTIONAL,
32612 c INTEGER OPTIONAL,
32613 COMPONENTS OF MySeq
32621 import from TempA all;
32622 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32623 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32625 const BERPDU myValue := {b := true,
32635 if ((enc_DER_PDU(myValue) == '310C8001FF8101058201FF830106'O)and(enc_CER_PDU(myValue) == '31808001FF8101058201FF8301060000'O)) {setverdict(pass);} else {setverdict(fail);}
32639 Overall verdict: pass
32645 .*---------------------------------------------------------------------*
32646 :h3.CER + DER encoding of SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
32647 .*---------------------------------------------------------------------*
32650 <TC - CER + DER encoding of SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
32666 {x INTEGER OPTIONAL,
32673 b [0] BOOLEAN OPTIONAL,
32674 c BIT STRING OPTIONAL,
32675 COMPONENTS OF MySeq
32683 import from TempA all;
32684 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32685 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32687 const BERPDU myValue := {b := true,
32697 if ((enc_DER_PDU(myValue) == '310D020106030207800401FF8001FF'O)and(enc_CER_PDU(myValue) == '3180020106030207800401FF8001FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
32701 Overall verdict: pass
32707 .*---------------------------------------------------------------------*
32708 :h3.CER + DER encoding of SET , (different order)one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
32709 .*---------------------------------------------------------------------*
32712 <TC - CER + DER encoding of SET , (different order)one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
32736 b [0] BOOLEAN OPTIONAL,
32737 c BIT STRING OPTIONAL,
32738 COMPONENTS OF MySeq
32746 import from TempA all;
32747 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32748 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32750 const BERPDU myValue := {b := true,
32760 if ((enc_DER_PDU(myValue) == '310D020106030207800401FF8001FF'O)and(enc_CER_PDU(myValue) == '3180020106030207800401FF8001FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
32764 Overall verdict: pass
32770 .*---------------------------------------------------------------------*
32771 :h3.CER + DER encoding of SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
32772 .*---------------------------------------------------------------------*
32775 <TC - CER + DER encoding of SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
32790 {x [1] INTEGER OPTIONAL,
32797 b [0] BOOLEAN OPTIONAL,
32798 c BIT STRING OPTIONAL,
32799 COMPONENTS OF MySeq
32808 import from TempA all;
32809 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32810 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32812 const BERPDU myValue := {b := true,
32822 if ((enc_DER_PDU(myValue) == '310D030207800401FF8001FF810106'O)and(enc_CER_PDU(myValue) == '3180030207800401FF8001FF8101060000'O)) {setverdict(pass);} else {setverdict(fail);}
32826 Overall verdict: pass
32832 .*---------------------------------------------------------------------*
32833 :h3.CER + DER encoding of SET ,(different order) one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
32834 .*---------------------------------------------------------------------*
32837 <TC - CER + DER encoding of SET ,(different order) one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
32853 x [1] INTEGER OPTIONAL
32860 b [0] BOOLEAN OPTIONAL,
32861 c BIT STRING OPTIONAL,
32862 COMPONENTS OF MySeq
32871 import from TempA all;
32872 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32873 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32875 const BERPDU myValue := {b := true,
32885 if ((enc_DER_PDU(myValue) == '310D030207800401FF8001FF810106'O)and(enc_CER_PDU(myValue) == '3180030207800401FF8001FF8101060000'O)) {setverdict(pass);} else {setverdict(fail);}
32889 Overall verdict: pass
32895 .*---------------------------------------------------------------------*
32896 :h3.CER + DER encoding of SET with CHOICE element, AUTOMATIC TAGS
32897 .*---------------------------------------------------------------------*
32900 <TC - CER + DER encoding of SET with CHOICE element, AUTOMATIC TAGS>
32936 import from TempA all;
32937 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
32938 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
32940 const BERPDU myValue := {b := {x := true},
32948 if ((enc_DER_PDU(myValue) == '3108A0038001FF810104'O)and(enc_CER_PDU(myValue) == '3180A0808001FF00008101040000'O)) {setverdict(pass);} else {setverdict(fail);}
32952 Overall verdict: pass
32958 .*---------------------------------------------------------------------*
32959 :h3. encoding of SET with CHOICE element (different order), AUTOMATIC TAGS
32960 .*---------------------------------------------------------------------*
32963 <TC - encoding of SET with CHOICE element (different order), AUTOMATIC TAGS>
32999 import from TempA all;
33000 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33001 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33003 const BERPDU myValue := {
33011 if ((enc_DER_PDU(myValue) == '3108A0038001FF810104'O)and(enc_CER_PDU(myValue) == '3180A0808001FF00008101040000'O)) {setverdict(pass);} else {setverdict(fail);}
33015 Overall verdict: pass
33021 .*---------------------------------------------------------------------*
33022 :h3. encoding of SET with CHOICE element (different order2), AUTOMATIC TAGS
33023 .*---------------------------------------------------------------------*
33026 <TC - encoding of SET with CHOICE element (different order2), AUTOMATIC TAGS>
33047 c INTEGER OPTIONAL,
33062 import from TempA all;
33063 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33064 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33066 const BERPDU myValue := {
33074 if ((enc_DER_PDU(myValue) == '3108800104A1038001FF'O)and(enc_CER_PDU(myValue) == '3180800104A1808001FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
33078 Overall verdict: pass
33084 .*---------------------------------------------------------------------*
33085 :h3.CER + DER encoding of SET with CHOICE element,
33086 .*---------------------------------------------------------------------*
33089 <TC - CER + DER encoding of SET with CHOICE element, >
33125 import from TempA all;
33126 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33127 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33129 const BERPDU myValue := {b := {x := true},
33137 if ((enc_DER_PDU(myValue) == '31060101FF020104'O)and(enc_CER_PDU(myValue) == '31800101FF0201040000'O)) {setverdict(pass);} else {setverdict(fail);}
33141 Overall verdict: pass
33147 .*---------------------------------------------------------------------*
33148 :h3. encoding of SET with CHOICE element,(different order)
33149 .*---------------------------------------------------------------------*
33152 <TC - encoding of SET with CHOICE element,(different order) >
33188 import from TempA all;
33189 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33190 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33192 const BERPDU myValue := {
33201 if ((enc_DER_PDU(myValue) == '31060101FF020104'O)and(enc_CER_PDU(myValue) == '31800101FF0201040000'O)) {setverdict(pass);} else {setverdict(fail);}
33205 Overall verdict: pass
33211 .*---------------------------------------------------------------------*
33212 :h3.CER + DER encoding of SET with CHOICE element,
33213 .*---------------------------------------------------------------------*
33216 <TC - CER + DER encoding of SET with CHOICE element, >
33252 import from TempA all;
33253 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33254 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33256 const BERPDU myValue := {b := {y := 'FF'O},
33264 if ((enc_DER_PDU(myValue) == '31060201040401FF'O)and(enc_CER_PDU(myValue) == '31800401FF0201040000'O)) {setverdict(pass);} else {setverdict(fail);}
33268 Overall verdict: pass
33274 .*---------------------------------------------------------------------*
33275 :h3.CER + DER encoding of SET with EXTENSION , AUTOMATIC TAGS
33276 .*---------------------------------------------------------------------*
33279 <TC - CER + DER encoding of SET with EXTENSION , AUTOMATIC TAGS>
33303 c INTEGER OPTIONAL,
33320 import from TempA all;
33321 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33322 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33324 const BERPDU myValue := {
33335 if ((enc_DER_PDU(myValue) == '310D8001FF8101FF82010483020780'O)and(enc_CER_PDU(myValue) == '31808001FF8101FF820104830207800000'O)) {setverdict(pass);} else {setverdict(fail);}
33339 Overall verdict: pass
33345 .*---------------------------------------------------------------------*
33346 :h3. encoding of SET with EXTENSION , (different order) AUTOMATIC TAGS
33347 .*---------------------------------------------------------------------*
33350 <TC - encoding of SET with EXTENSION , (different order) AUTOMATIC TAGS>
33374 c INTEGER OPTIONAL,
33391 import from TempA all;
33392 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33393 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33395 const BERPDU myValue := {
33406 if ((enc_DER_PDU(myValue) == '310D8001FF8101FF82010483020780'O)and(enc_CER_PDU(myValue) == '31808001FF8101FF820104830207800000'O)) {setverdict(pass);} else {setverdict(fail);}
33410 Overall verdict: pass
33416 .*---------------------------------------------------------------------*
33417 :h3.CER + DER encoding of SET (EMPTY)
33418 .*---------------------------------------------------------------------*
33421 <TC - CER + DER encoding of SET (EMPTY)>
33435 d ENUMERATED {first ,second ,third},
33440 h OBJECT IDENTIFIER,
33442 j CHOICE {x1 [1] BOOLEAN,
33443 y1 [2] OCTET STRING},
33445 k SEQUENCE{x2 NULL,
33448 l SET { x3 BIT STRING,
33451 m [3] SEQUENCE OF INTEGER,
33452 n [4] SET OF BOOLEAN
33455 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
33462 import from TempA all;
33463 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33464 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33466 const BERPDU myValue := {a := NULL,
33475 j := {x1 := true } ,
33495 if ((enc_DER_PDU(myValue) == '31530101FF020102030207800402FFFF05000603000203090603312E452B300A0100300505000101FF310C03020780090603312E452B301603414243A1030101FFA3083006020101020102A40831060101FF0101FF'O)and(enc_CER_PDU(myValue) == '31800101FF020102030207800402FFFF05000603000203090603312E452B300A0100308005000101FF0000318003020780090603312E452B3000001603414243A1800101FF0000A380308002010102010200000000A48031800101FF0101FF000000000000'O)) {setverdict(pass);} else {setverdict(fail);}
33499 Overall verdict: pass
33505 .*---------------------------------------------------------------------*
33506 :h3.CER + DER encoding of SET with fields of different types, AUTOMATIC TAGS
33507 .*---------------------------------------------------------------------*
33510 <TC - CER + DER encoding of SET with fields of different types, AUTOMATIC TAGS>
33529 d ENUMERATED {first ,second ,third},
33534 h OBJECT IDENTIFIER,
33536 j CHOICE {x1 BOOLEAN,
33539 k SEQUENCE{x2 NULL,
33542 l SET { x3 BIT STRING,
33545 m SEQUENCE OF INTEGER,
33550 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
33557 import from TempA all;
33558 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33559 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33561 const BERPDU myValue := {a := NULL,
33570 j := {x1 := true } ,
33592 if ((enc_DER_PDU(myValue) == '314F80008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB0C80020780810603312E452B30AC06020101020102AD060101FF0101FF'O)and(enc_CER_PDU(myValue) == '318080008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB8080020780810603312E452B300000AC800201010201020000AD800101FF0101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
33596 Overall verdict: pass
33602 .*---------------------------------------------------------------------*
33603 :h3.CER + DER encoding of SET with fields of different types (different order), AUTOMATIC TAGS
33604 .*---------------------------------------------------------------------*
33607 <TC - CER + DER encoding of SET with fields of different types (different order), AUTOMATIC TAGS>
33626 d ENUMERATED {first ,second ,third},
33631 h OBJECT IDENTIFIER,
33633 j CHOICE {x1 BOOLEAN,
33636 k SEQUENCE{x2 NULL,
33639 l SET { x3 BIT STRING,
33642 m SEQUENCE OF INTEGER,
33647 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
33654 import from TempA all;
33655 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33656 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33658 const BERPDU myValue := {a := NULL,
33667 j := {x1 := true } ,
33685 if ((enc_DER_PDU(myValue) == '314F80008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB0C80020780810603312E452B30AC06020101020102AD060101FF0101FF'O)and(enc_CER_PDU(myValue) == '318080008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB8080020780810603312E452B300000AC800201010201020000AD800101FF0101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
33689 Overall verdict: pass
33695 .*---------------------------------------------------------------------*
33696 :h3.CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGGING
33697 .*---------------------------------------------------------------------*
33700 <TC - CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGGING>
33717 d [PRIVATE 0] INTEGER OPTIONAL,
33718 a INTEGER OPTIONAL,
33719 b [APPLICATION 0] INTEGER OPTIONAL,
33720 c [0] INTEGER OPTIONAL
33729 import from TempA all;
33730 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33731 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33733 const BERPDU myValue := {
33744 if ((enc_DER_PDU(myValue) == '310C020101400102800103C00104'O)and(enc_CER_PDU(myValue) == '3180020101400102800103C001040000'O)) {setverdict(pass);} else {setverdict(fail);}
33748 Overall verdict: pass
33754 .*---------------------------------------------------------------------*
33755 :h3.CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )
33756 .*---------------------------------------------------------------------*
33759 <TC - CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )>
33774 d [PRIVATE 0] INTEGER OPTIONAL,
33775 a INTEGER OPTIONAL,
33776 b [APPLICATION 0] INTEGER OPTIONAL,
33777 c [0] INTEGER OPTIONAL
33786 import from TempA all;
33787 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33788 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33790 const BERPDU myValue := {
33801 if ((enc_DER_PDU(myValue) == '31120201016003020102A003020103E003020104'O)and(enc_CER_PDU(myValue) == '318002010160800201020000A0800201030000E08002010400000000'O)) {setverdict(pass);} else {setverdict(fail);}
33805 Overall verdict: pass
33811 .*---------------------------------------------------------------------*
33812 :h3.CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGGING
33813 .*---------------------------------------------------------------------*
33816 <TC - CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGGING>
33832 d [PRIVATE 0] INTEGER OPTIONAL,
33833 a INTEGER OPTIONAL,
33834 b [APPLICATION 0] INTEGER OPTIONAL,
33835 c [0] INTEGER OPTIONAL
33844 import from TempA all;
33845 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33846 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33848 const BERPDU myValue := {
33859 if ((enc_DER_PDU(myValue) == '31120201016003020102A003020103E003020104'O)and(enc_CER_PDU(myValue) == '318002010160800201020000A0800201030000E08002010400000000'O)) {setverdict(pass);} else {setverdict(fail);}
33863 Overall verdict: pass
33869 .*---------------------------------------------------------------------*
33870 :h3.CER + DER encoding of SET including untagged CHOICE (spec example) IMPLICIT TAGS
33871 .*---------------------------------------------------------------------*
33874 <TC - CER + DER encoding of SET including untagged CHOICE (spec example) IMPLICIT TAGS>
33918 import from TempA all;
33919 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33920 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33922 const BERPDU myValue := {
33925 e := { f := {g := 3 } }
33933 if ((enc_DER_PDU(myValue) == '310BA103820102830101850103'O)and(enc_CER_PDU(myValue) == '3180850103A18082010200008301010000'O)) {setverdict(pass);} else {setverdict(fail);}
33937 Overall verdict: pass
33943 .*---------------------------------------------------------------------*
33944 :h3.CER + DER encoding of SET including untagged CHOICE (spec example) EXPLICIT TAGS
33945 .*---------------------------------------------------------------------*
33948 <TC - CER + DER encoding of SET including untagged CHOICE (spec example) EXPLICIT TAGS>
33992 import from TempA all;
33993 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
33994 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
33996 const BERPDU myValue := {
33999 e := { f := { g := 3 } }
34007 if ((enc_DER_PDU(myValue) == '3111A105A203020102A303020101A503020103'O)and(enc_CER_PDU(myValue) == '3180A5800201030000A180A28002010200000000A38002010100000000'O)) {setverdict(pass);} else {setverdict(fail);}
34011 Overall verdict: pass
34017 .*---------------------------------------------------------------------*
34018 :h3. DECODING DER , SET (EMPTY)
34019 .*---------------------------------------------------------------------*
34022 <TC - DECODING DER , SET (EMPTY)>
34032 b BOOLEAN OPTIONAL,
34040 import from TempA all;
34042 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34045 const BERPDU myValue := {b := omit,
34050 if (dec_BER_PDU('3100'O) == myValue)
34054 {setverdict(pass);} else {setverdict(fail);}
34059 Overall verdict: pass
34065 .*---------------------------------------------------------------------*
34066 :h3. DECODING CER , SET (EMPTY)
34067 .*---------------------------------------------------------------------*
34070 <TC - DECODING CER , SET (EMPTY)>
34080 b BOOLEAN OPTIONAL,
34088 import from TempA all;
34090 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34093 const BERPDU myValue := {b := omit,
34098 if (dec_BER_PDU('31800000'O) == myValue)
34102 {setverdict(pass);} else {setverdict(fail);}
34107 Overall verdict: pass
34113 .*---------------------------------------------------------------------*
34114 :h3.DECODING DER , SET (only one element is used)
34115 .*---------------------------------------------------------------------*
34118 <TC - DECODING DER , SET (only one element is used)>
34128 b BOOLEAN OPTIONAL,
34137 import from TempA all;
34139 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34142 const BERPDU myValue := {b := true,
34147 if (dec_BER_PDU('31030101FF'O) == myValue)
34151 {setverdict(pass);} else {setverdict(fail);}
34156 Overall verdict: pass
34162 .*---------------------------------------------------------------------*
34163 :h3.DECODING CER , SET (only one element is used)
34164 .*---------------------------------------------------------------------*
34167 <TC - DECODING CER , SET (only one element is used)>
34177 b BOOLEAN OPTIONAL,
34186 import from TempA all;
34188 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34191 const BERPDU myValue := {b := true,
34196 if (dec_BER_PDU('31800101FF0000'O) == myValue)
34200 {setverdict(pass);} else {setverdict(fail);}
34205 Overall verdict: pass
34211 .*---------------------------------------------------------------------*
34212 :h3. DECODING DER , SET (both elements are used)
34213 .*---------------------------------------------------------------------*
34216 <TC - DECODING DER , SET (both elements are used)>
34226 b BOOLEAN OPTIONAL,
34235 import from TempA all;
34237 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34240 const BERPDU myValue := {b := true,
34246 if (dec_BER_PDU('31060101FF020105'O) == myValue)
34250 {setverdict(pass);} else {setverdict(fail);}
34255 Overall verdict: pass
34261 .*---------------------------------------------------------------------*
34262 :h3. DECODING CER , SET (both elements are used)
34263 .*---------------------------------------------------------------------*
34266 <TC - DECODING CER , SET (both elements are used)>
34276 b BOOLEAN OPTIONAL,
34285 import from TempA all;
34287 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34290 const BERPDU myValue := {b := true,
34296 if (dec_BER_PDU('31800101FF0201050000'O) == myValue)
34300 {setverdict(pass);} else {setverdict(fail);}
34305 Overall verdict: pass
34311 .*---------------------------------------------------------------------*
34312 :h3. DECODING ,different order , SET (both elements are used)
34313 .*---------------------------------------------------------------------*
34316 <TC - DECODING ,different order , SET (both elements are used)>
34327 c INTEGER OPTIONAL,
34336 import from TempA all;
34338 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34341 const BERPDU myValue := {b := true,
34347 if (dec_BER_PDU('31060201050101FF'O) == myValue)
34351 {setverdict(pass);} else {setverdict(fail);}
34356 Overall verdict: pass
34362 .*---------------------------------------------------------------------*
34363 :h3. DECODING , different order, SET (both elements are used)
34364 .*---------------------------------------------------------------------*
34367 <TC - DECODING , different order, SET (both elements are used)>
34378 c INTEGER OPTIONAL,
34387 import from TempA all;
34389 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34392 const BERPDU myValue := {
34399 if (dec_BER_PDU('31800201050101FF0000'O) == myValue)
34403 {setverdict(pass);} else {setverdict(fail);}
34408 Overall verdict: pass
34414 .*---------------------------------------------------------------------*
34415 :h3. DECODING DER , SET (one element is equal to Default)
34416 .*---------------------------------------------------------------------*
34419 <TC - DECODING DER , SET (one element is equal to Default)>
34429 b BOOLEAN DEFAULT TRUE,
34437 import from TempA all;
34439 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34442 const BERPDU myValue := {b := true,
34446 if (dec_BER_PDU('3103020105'O) == myValue)
34450 {setverdict(pass);} else {setverdict(fail);}
34455 Overall verdict: pass
34461 .*---------------------------------------------------------------------*
34462 :h3. DECODING CER, SET (one element is equal to Default)
34463 .*---------------------------------------------------------------------*
34466 <TC - DECODING CER, SET (one element is equal to Default)>
34476 b BOOLEAN DEFAULT TRUE,
34484 import from TempA all;
34486 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34489 const BERPDU myValue := {b := true,
34493 if (dec_BER_PDU('31800201050000'O) == myValue)
34497 {setverdict(pass);} else {setverdict(fail);}
34502 Overall verdict: pass
34508 .*---------------------------------------------------------------------*
34509 :h3. DECODING, default included , SET (one element is equal to Default)
34510 .*---------------------------------------------------------------------*
34513 <TC - DECODING, default included , SET (one element is equal to Default)>
34523 b BOOLEAN DEFAULT TRUE,
34531 import from TempA all;
34533 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34536 const BERPDU myValue := {b := true,
34540 if (dec_BER_PDU('31060201050101FF'O) == myValue)
34544 {setverdict(pass);} else {setverdict(fail);}
34549 Overall verdict: pass
34555 .*---------------------------------------------------------------------*
34556 :h3. DECODING , default included, SET (one element is equal to Default)
34557 .*---------------------------------------------------------------------*
34560 <TC - DECODING , default included, SET (one element is equal to Default)>
34570 b BOOLEAN DEFAULT TRUE,
34578 import from TempA all;
34580 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34583 const BERPDU myValue := {b := true,
34587 if (dec_BER_PDU('31800101FF0201050000'O) == myValue)
34591 {setverdict(pass);} else {setverdict(fail);}
34596 Overall verdict: pass
34602 .*---------------------------------------------------------------------*
34603 :h3. DECODING DER , SET (one element is not equal to Default)
34604 .*---------------------------------------------------------------------*
34607 <TC - DECODING DER , SET (one element is not equal to Default)>
34618 b BOOLEAN DEFAULT TRUE,
34627 import from TempA all;
34629 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34632 const BERPDU myValue := {b := false,
34636 if (dec_BER_PDU('3106010100020105'O) == myValue)
34640 {setverdict(pass);} else {setverdict(fail);}
34645 Overall verdict: pass
34651 .*---------------------------------------------------------------------*
34652 :h3. DECODING CER , SET (one element is not equal to Default)
34653 .*---------------------------------------------------------------------*
34656 <TC - DECODING CER , SET (one element is not equal to Default)>
34667 b BOOLEAN DEFAULT TRUE,
34676 import from TempA all;
34678 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34681 const BERPDU myValue := {b := false,
34685 if (dec_BER_PDU('31800101000201050000'O) == myValue)
34689 {setverdict(pass);} else {setverdict(fail);}
34694 Overall verdict: pass
34700 .*---------------------------------------------------------------------*
34701 :h3. DECODING, reverse order , SET (one element is not equal to Default)
34702 .*---------------------------------------------------------------------*
34705 <TC - DECODING, reverse order , SET (one element is not equal to Default)>
34716 b BOOLEAN DEFAULT TRUE,
34725 import from TempA all;
34727 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34730 const BERPDU myValue := {b := false,
34734 if (dec_BER_PDU('3106020105010100'O) == myValue)
34738 {setverdict(pass);} else {setverdict(fail);}
34743 Overall verdict: pass
34749 .*---------------------------------------------------------------------*
34750 :h3. DECODING ,reverse order , SET (one element is not equal to Default)
34751 .*---------------------------------------------------------------------*
34754 <TC - DECODING ,reverse order , SET (one element is not equal to Default)>
34765 b BOOLEAN DEFAULT TRUE,
34774 import from TempA all;
34776 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34779 const BERPDU myValue := {b := false,
34783 if (dec_BER_PDU('31800201050101000000'O) == myValue)
34787 {setverdict(pass);} else {setverdict(fail);}
34792 Overall verdict: pass
34798 .*---------------------------------------------------------------------*
34799 :h3. DECODING DER , SET (EMPTY), AUTOMATIC TAGGING
34800 .*---------------------------------------------------------------------*
34803 <TC - DECODING DER , SET (EMPTY), AUTOMATIC TAGGING>
34820 b BOOLEAN OPTIONAL,
34829 import from TempA all;
34831 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34834 const BERPDU myValue := {b := omit,
34839 if (dec_BER_PDU('3100'O) == myValue)
34843 {setverdict(pass);} else {setverdict(fail);}
34848 Overall verdict: pass
34854 .*---------------------------------------------------------------------*
34855 :h3. DECODING CER , SET (EMPTY), AUTOMATIC TAGGING
34856 .*---------------------------------------------------------------------*
34859 <TC - DECODING CER , SET (EMPTY), AUTOMATIC TAGGING>
34876 b BOOLEAN OPTIONAL,
34885 import from TempA all;
34887 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34890 const BERPDU myValue := {b := omit,
34895 if (dec_BER_PDU('31800000'O) == myValue)
34899 {setverdict(pass);} else {setverdict(fail);}
34904 Overall verdict: pass
34910 .*---------------------------------------------------------------------*
34911 :h3. DECODING DER , SET (only one element is used) AUTOMATIC TAGGING
34912 .*---------------------------------------------------------------------*
34915 <TC - DECODING DER , SET (only one element is used) AUTOMATIC TAGGING>
34933 b BOOLEAN OPTIONAL,
34942 import from TempA all;
34944 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
34947 const BERPDU myValue := {b := true,
34952 if (dec_BER_PDU('31038001FF'O) == myValue)
34956 {setverdict(pass);} else {setverdict(fail);}
34961 Overall verdict: pass
34967 .*---------------------------------------------------------------------*
34968 :h3. DECODING CER , SET (only one element is used) AUTOMATIC TAGGING
34969 .*---------------------------------------------------------------------*
34972 <TC - DECODING CER , SET (only one element is used) AUTOMATIC TAGGING>
34990 b BOOLEAN OPTIONAL,
34999 import from TempA all;
35001 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35004 const BERPDU myValue := {b := true,
35009 if (dec_BER_PDU('31808001FF0000'O) == myValue)
35013 {setverdict(pass);} else {setverdict(fail);}
35018 Overall verdict: pass
35024 .*---------------------------------------------------------------------*
35025 :h3. DECODING DER , SET (both elements are used) AUTOMATIC TAGGING
35026 .*---------------------------------------------------------------------*
35029 <TC - DECODING DER , SET (both elements are used) AUTOMATIC TAGGING>
35047 b BOOLEAN OPTIONAL,
35057 import from TempA all;
35059 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35062 const BERPDU myValue := {b := true,
35067 if (dec_BER_PDU('31068001FF810105'O) == myValue)
35071 {setverdict(pass);} else {setverdict(fail);}
35076 Overall verdict: pass
35082 .*---------------------------------------------------------------------*
35083 :h3. DECODING CER , SET (both elements are used) AUTOMATIC TAGGING
35084 .*---------------------------------------------------------------------*
35087 <TC - DECODING CER , SET (both elements are used) AUTOMATIC TAGGING>
35105 b BOOLEAN OPTIONAL,
35115 import from TempA all;
35117 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35120 const BERPDU myValue := {b := true,
35125 if (dec_BER_PDU('31808001FF8101050000'O) == myValue)
35129 {setverdict(pass);} else {setverdict(fail);}
35134 Overall verdict: pass
35140 .*---------------------------------------------------------------------*
35141 :h3. DECODING ,reverse order , SET (both elements are used) AUTOMATIC TAGGING
35142 .*---------------------------------------------------------------------*
35145 <TC - DECODING ,reverse order , SET (both elements are used) AUTOMATIC TAGGING>
35163 b BOOLEAN OPTIONAL,
35173 import from TempA all;
35175 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35178 const BERPDU myValue := {b := true,
35183 if (dec_BER_PDU('31068101058001FF'O) == myValue)
35187 {setverdict(pass);} else {setverdict(fail);}
35192 Overall verdict: pass
35198 .*---------------------------------------------------------------------*
35199 :h3. DECODING, reverse order , SET (both elements are used) AUTOMATIC TAGGING
35200 .*---------------------------------------------------------------------*
35203 <TC - DECODING, reverse order , SET (both elements are used) AUTOMATIC TAGGING>
35221 b BOOLEAN OPTIONAL,
35231 import from TempA all;
35233 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35236 const BERPDU myValue := {b := true,
35241 if (dec_BER_PDU('31808101058001FF0000'O) == myValue)
35245 {setverdict(pass);} else {setverdict(fail);}
35250 Overall verdict: pass
35256 .*---------------------------------------------------------------------*
35257 :h3. DECODING DER , SET (one element is equal to Default) AUTOMATIC TAGGING
35258 .*---------------------------------------------------------------------*
35261 <TC - DECODING DER , SET (one element is equal to Default) AUTOMATIC TAGGING >
35279 b BOOLEAN DEFAULT TRUE,
35289 import from TempA all;
35291 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35294 const BERPDU myValue := {b := true,
35299 if (dec_BER_PDU('3103810105'O) == myValue)
35303 {setverdict(pass);} else {setverdict(fail);}
35308 Overall verdict: pass
35314 .*---------------------------------------------------------------------*
35315 :h3. DECODING CER , SET (one element is equal to Default) AUTOMATIC TAGGING
35316 .*---------------------------------------------------------------------*
35319 <TC - DECODING CER , SET (one element is equal to Default) AUTOMATIC TAGGING >
35337 b BOOLEAN DEFAULT TRUE,
35347 import from TempA all;
35349 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35352 const BERPDU myValue := {b := true,
35357 if (dec_BER_PDU('31808101050000'O) == myValue)
35361 {setverdict(pass);} else {setverdict(fail);}
35366 Overall verdict: pass
35372 .*---------------------------------------------------------------------*
35373 :h3. DECODING , default included , SET (one element is equal to Default) AUTOMATIC TAGGING
35374 .*---------------------------------------------------------------------*
35377 <TC - DECODING , default included , SET (one element is equal to Default) AUTOMATIC TAGGING >
35395 b BOOLEAN DEFAULT TRUE,
35405 import from TempA all;
35407 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35410 const BERPDU myValue := {b := true,
35415 if (dec_BER_PDU('31068001FF810105'O) == myValue)
35419 {setverdict(pass);} else {setverdict(fail);}
35424 Overall verdict: pass
35430 .*---------------------------------------------------------------------*
35431 :h3. DECODING , default included, SET (one element is equal to Default) AUTOMATIC TAGGING
35432 .*---------------------------------------------------------------------*
35435 <TC - DECODING , default included, SET (one element is equal to Default) AUTOMATIC TAGGING >
35453 b BOOLEAN DEFAULT TRUE,
35463 import from TempA all;
35465 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35468 const BERPDU myValue := {b := true,
35473 if (dec_BER_PDU('31808101058001FF0000'O) == myValue)
35477 {setverdict(pass);} else {setverdict(fail);}
35482 Overall verdict: pass
35488 .*---------------------------------------------------------------------*
35489 :h3. DECODING DER ,SET (one element is not equal to Default) AUTOMATIC TAGGING
35490 .*---------------------------------------------------------------------*
35493 <TC - DECODING DER ,SET (one element is not equal to Default) AUTOMATIC TAGGING>
35511 b BOOLEAN DEFAULT TRUE,
35521 import from TempA all;
35523 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35526 const BERPDU myValue := {b := false,
35531 if (dec_BER_PDU('3106800100810105'O) == myValue)
35535 {setverdict(pass);} else {setverdict(fail);}
35540 Overall verdict: pass
35546 .*---------------------------------------------------------------------*
35547 :h3. DECODING CER ,SET (one element is not equal to Default) AUTOMATIC TAGGING
35548 .*---------------------------------------------------------------------*
35551 <TC - DECODING CER ,SET (one element is not equal to Default) AUTOMATIC TAGGING>
35569 b BOOLEAN DEFAULT TRUE,
35579 import from TempA all;
35581 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35584 const BERPDU myValue := {b := false,
35589 if (dec_BER_PDU('31808001008101050000'O) == myValue)
35593 {setverdict(pass);} else {setverdict(fail);}
35598 Overall verdict: pass
35604 .*---------------------------------------------------------------------*
35605 :h3. DECODING,reverse order,SET (one element is not equal to Default) AUTOMATIC TAGGING
35606 .*---------------------------------------------------------------------*
35609 <TC - DECODING,reverse order,SET (one element is not equal to Default) AUTOMATIC TAGGING>
35627 b BOOLEAN DEFAULT TRUE,
35637 import from TempA all;
35639 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35642 const BERPDU myValue := {b := false,
35647 if (dec_BER_PDU('3106810105800100'O) == myValue)
35651 {setverdict(pass);} else {setverdict(fail);}
35656 Overall verdict: pass
35662 .*---------------------------------------------------------------------*
35663 :h3. DECODING CER ,SET (one element is not equal to Default) AUTOMATIC TAGGING
35664 .*---------------------------------------------------------------------*
35667 <TC - DECODING CER ,SET (one element is not equal to Default) AUTOMATIC TAGGING>
35685 b BOOLEAN DEFAULT TRUE,
35695 import from TempA all;
35697 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35700 const BERPDU myValue := {b := false,
35705 if (dec_BER_PDU('31808101058001000000'O) == myValue)
35709 {setverdict(pass);} else {setverdict(fail);}
35714 Overall verdict: pass
35720 .*---------------------------------------------------------------------*
35721 :h3. DECODING DER , SET (both elements are used) IMPLICIT TAGS for elements
35722 .*---------------------------------------------------------------------*
35725 <TC - DECODING DER , SET (both elements are used) IMPLICIT TAGS for elements>
35743 b [30] IMPLICIT BOOLEAN OPTIONAL,
35744 c [31] IMPLICIT INTEGER OPTIONAL
35752 import from TempA all;
35754 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35757 const BERPDU myValue := {b := true,
35762 if (dec_BER_PDU('31079E01FF9F1F0105'O) == myValue)
35766 {setverdict(pass);} else {setverdict(fail);}
35771 Overall verdict: pass
35777 .*---------------------------------------------------------------------*
35778 :h3. DECODING CER , SET (both elements are used) IMPLICIT TAGS for elements
35779 .*---------------------------------------------------------------------*
35782 <TC - DECODING CER , SET (both elements are used) IMPLICIT TAGS for elements>
35800 b [30] IMPLICIT BOOLEAN OPTIONAL,
35801 c [31] IMPLICIT INTEGER OPTIONAL
35809 import from TempA all;
35811 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35814 const BERPDU myValue := {b := true,
35819 if (dec_BER_PDU('31809E01FF9F1F01050000'O) == myValue)
35823 {setverdict(pass);} else {setverdict(fail);}
35828 Overall verdict: pass
35834 .*---------------------------------------------------------------------*
35835 :h3. DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements
35836 .*---------------------------------------------------------------------*
35839 <TC - DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements>
35857 b [30] IMPLICIT BOOLEAN OPTIONAL,
35858 c [31] IMPLICIT INTEGER OPTIONAL
35866 import from TempA all;
35868 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35871 const BERPDU myValue := {b := true,
35876 if (dec_BER_PDU('31079F1F01059E01FF'O) == myValue)
35880 {setverdict(pass);} else {setverdict(fail);}
35885 Overall verdict: pass
35891 .*---------------------------------------------------------------------*
35892 :h3. DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements
35893 .*---------------------------------------------------------------------*
35896 <TC - DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements>
35914 b [30] IMPLICIT BOOLEAN OPTIONAL,
35915 c [31] IMPLICIT INTEGER OPTIONAL
35923 import from TempA all;
35925 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35928 const BERPDU myValue := {b := true,
35933 if (dec_BER_PDU('31809F1F01059E01FF0000'O) == myValue)
35937 {setverdict(pass);} else {setverdict(fail);}
35942 Overall verdict: pass
35948 .*---------------------------------------------------------------------*
35949 :h3. DECODING DER , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
35950 .*---------------------------------------------------------------------*
35953 <TC - DECODING DER , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
35971 b [30] IMPLICIT BOOLEAN OPTIONAL,
35972 c [31] IMPLICIT INTEGER OPTIONAL
35981 import from TempA all;
35983 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
35986 const BERPDU myValue := {b := true,
35992 if (dec_BER_PDU('31079E01FF9F1F0105'O) == myValue)
35996 {setverdict(pass);} else {setverdict(fail);}
36001 Overall verdict: pass
36007 .*---------------------------------------------------------------------*
36008 :h3. DECODING CER , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
36009 .*---------------------------------------------------------------------*
36012 <TC - DECODING CER , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
36030 b [30] IMPLICIT BOOLEAN OPTIONAL,
36031 c [31] IMPLICIT INTEGER OPTIONAL
36040 import from TempA all;
36042 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36045 const BERPDU myValue := {b := true,
36051 if (dec_BER_PDU('31809E01FF9F1F01050000'O) == myValue)
36055 {setverdict(pass);} else {setverdict(fail);}
36060 Overall verdict: pass
36066 .*---------------------------------------------------------------------*
36067 :h3. DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
36068 .*---------------------------------------------------------------------*
36071 <TC - DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
36089 b [30] IMPLICIT BOOLEAN OPTIONAL,
36090 c [31] IMPLICIT INTEGER OPTIONAL
36099 import from TempA all;
36101 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36104 const BERPDU myValue := {b := true,
36110 if (dec_BER_PDU('31079F1F01059E01FF'O) == myValue)
36114 {setverdict(pass);} else {setverdict(fail);}
36119 Overall verdict: pass
36125 .*---------------------------------------------------------------------*
36126 :h3. DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT
36127 .*---------------------------------------------------------------------*
36130 <TC - DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT>
36148 b [30] IMPLICIT BOOLEAN OPTIONAL,
36149 c [31] IMPLICIT INTEGER OPTIONAL
36158 import from TempA all;
36160 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36163 const BERPDU myValue := {b := true,
36169 if (dec_BER_PDU('31809F1F01059E01FF0000'O) == myValue)
36173 {setverdict(pass);} else {setverdict(fail);}
36178 Overall verdict: pass
36184 .*---------------------------------------------------------------------*
36185 :h3. DECODING DER, SET (both elements are used) EXPLICIT TAGS for elements
36186 .*---------------------------------------------------------------------*
36189 <TC - DECODING DER, SET (both elements are used) EXPLICIT TAGS for elements>
36206 b [30] EXPLICIT BOOLEAN OPTIONAL,
36207 c [31] EXPLICIT INTEGER OPTIONAL
36216 import from TempA all;
36218 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36221 const BERPDU myValue := {b := true,
36227 if (dec_BER_PDU('310BBE030101FFBF1F03020105'O) == myValue)
36231 {setverdict(pass);} else {setverdict(fail);}
36236 Overall verdict: pass
36242 .*---------------------------------------------------------------------*
36243 :h3. DECODING CER, SET (both elements are used) EXPLICIT TAGS for elements
36244 .*---------------------------------------------------------------------*
36247 <TC - DECODING CER, SET (both elements are used) EXPLICIT TAGS for elements>
36264 b [30] EXPLICIT BOOLEAN OPTIONAL,
36265 c [31] EXPLICIT INTEGER OPTIONAL
36274 import from TempA all;
36276 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36279 const BERPDU myValue := {b := true,
36285 if (dec_BER_PDU('3180BE800101FF0000BF1F8002010500000000'O) == myValue)
36289 {setverdict(pass);} else {setverdict(fail);}
36294 Overall verdict: pass
36300 .*---------------------------------------------------------------------*
36301 :h3. DECODING , reverse order, SET (both elements are used) EXPLICIT TAGS for elements
36302 .*---------------------------------------------------------------------*
36305 <TC - DECODING , reverse order, SET (both elements are used) EXPLICIT TAGS for elements>
36322 b [30] EXPLICIT BOOLEAN OPTIONAL,
36323 c [31] EXPLICIT INTEGER OPTIONAL
36332 import from TempA all;
36334 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36337 const BERPDU myValue := {b := true,
36343 if (dec_BER_PDU('310BBF1F03020105BE030101FF'O) == myValue)
36347 {setverdict(pass);} else {setverdict(fail);}
36352 Overall verdict: pass
36358 .*---------------------------------------------------------------------*
36359 :h3. DECODING , reverse order, SET (both elements are used) EXPLICIT TAGS for elements
36360 .*---------------------------------------------------------------------*
36363 <TC - DECODING , reverse order, SET (both elements are used) EXPLICIT TAGS for elements>
36380 b [30] EXPLICIT BOOLEAN OPTIONAL,
36381 c [31] EXPLICIT INTEGER OPTIONAL
36390 import from TempA all;
36392 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36395 const BERPDU myValue := {b := true,
36401 if (dec_BER_PDU('3180BF1F800201050000BE800101FF00000000'O) == myValue)
36405 {setverdict(pass);} else {setverdict(fail);}
36410 Overall verdict: pass
36416 .*---------------------------------------------------------------------*
36417 :h3. DECODING DER , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
36418 .*---------------------------------------------------------------------*
36421 <TC - DECODING DER , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
36439 b [30] EXPLICIT BOOLEAN OPTIONAL,
36440 c [31] EXPLICIT INTEGER OPTIONAL
36448 import from TempA all;
36450 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36453 const BERPDU myValue := {b := true,
36460 if (dec_BER_PDU('310BBE030101FFBF1F03020105'O) == myValue)
36464 {setverdict(pass);} else {setverdict(fail);}
36469 Overall verdict: pass
36475 .*---------------------------------------------------------------------*
36476 :h3. DECODING CER , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
36477 .*---------------------------------------------------------------------*
36480 <TC - DECODING CER , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
36498 b [30] EXPLICIT BOOLEAN OPTIONAL,
36499 c [31] EXPLICIT INTEGER OPTIONAL
36507 import from TempA all;
36509 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36512 const BERPDU myValue := {b := true,
36519 if (dec_BER_PDU('3180BE800101FF0000BF1F8002010500000000'O) == myValue)
36523 {setverdict(pass);} else {setverdict(fail);}
36528 Overall verdict: pass
36534 .*---------------------------------------------------------------------*
36535 :h3. DECODING , reverse order , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
36536 .*---------------------------------------------------------------------*
36539 <TC - DECODING , reverse order , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
36557 b [30] EXPLICIT BOOLEAN OPTIONAL,
36558 c [31] EXPLICIT INTEGER OPTIONAL
36566 import from TempA all;
36568 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36571 const BERPDU myValue := {b := true,
36578 if (dec_BER_PDU('310BBF1F03020105BE030101FF'O) == myValue)
36582 {setverdict(pass);} else {setverdict(fail);}
36587 Overall verdict: pass
36593 .*---------------------------------------------------------------------*
36594 :h3. DECODING , reverse order , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT
36595 .*---------------------------------------------------------------------*
36598 <TC - DECODING , reverse order , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT>
36616 b [30] EXPLICIT BOOLEAN OPTIONAL,
36617 c [31] EXPLICIT INTEGER OPTIONAL
36625 import from TempA all;
36627 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36630 const BERPDU myValue := {b := true,
36637 if (dec_BER_PDU('3180BF1F800201050000BE800101FF00000000'O) == myValue)
36641 {setverdict(pass);} else {setverdict(fail);}
36646 Overall verdict: pass
36652 .*---------------------------------------------------------------------*
36653 :h3. DECODING , DER , TAGGED SET (both elements are used)
36654 .*---------------------------------------------------------------------*
36657 <TC - DECODING , DER , TAGGED SET (both elements are used)>
36674 b BOOLEAN OPTIONAL,
36683 import from TempA all;
36685 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36688 const BERPDU myValue := {b := true,
36695 if (dec_BER_PDU('A00831060101FF020105'O) == myValue)
36699 {setverdict(pass);} else {setverdict(fail);}
36704 Overall verdict: pass
36710 .*---------------------------------------------------------------------*
36711 :h3. DECODING , CER , TAGGED SET (both elements are used)
36712 .*---------------------------------------------------------------------*
36715 <TC - DECODING , CER , TAGGED SET (both elements are used)>
36732 b BOOLEAN OPTIONAL,
36741 import from TempA all;
36743 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36746 const BERPDU myValue := {b := true,
36753 if (dec_BER_PDU('A08031800101FF02010500000000'O) == myValue)
36757 {setverdict(pass);} else {setverdict(fail);}
36762 Overall verdict: pass
36768 .*---------------------------------------------------------------------*
36769 :h3. DECODING , reverse order , TAGGED SET (both elements are used)
36770 .*---------------------------------------------------------------------*
36773 <TC - DECODING , reverse order , TAGGED SET (both elements are used)>
36790 b BOOLEAN OPTIONAL,
36799 import from TempA all;
36801 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36804 const BERPDU myValue := {b := true,
36811 if (dec_BER_PDU('A00831060201050101FF'O) == myValue)
36815 {setverdict(pass);} else {setverdict(fail);}
36820 Overall verdict: pass
36826 .*---------------------------------------------------------------------*
36827 :h3. DECODING ,reverse order , TAGGED SET (both elements are used)
36828 .*---------------------------------------------------------------------*
36831 <TC - DECODING ,reverse order , TAGGED SET (both elements are used)>
36848 b BOOLEAN OPTIONAL,
36857 import from TempA all;
36859 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36862 const BERPDU myValue := {b := true,
36869 if (dec_BER_PDU('A08031800201050101FF00000000'O) == myValue)
36873 {setverdict(pass);} else {setverdict(fail);}
36878 Overall verdict: pass
36884 .*---------------------------------------------------------------------*
36885 :h3. DECODING DER , TAGGED SEQUENCE (both elements are used)
36886 .*---------------------------------------------------------------------*
36889 <TC - DECODING DER , TAGGED SEQUENCE (both elements are used)>
36904 BERPDU ::= [0] SEQUENCE
36906 b BOOLEAN OPTIONAL,
36914 import from TempA all;
36916 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36919 const BERPDU myValue := {b := true,
36926 if (dec_BER_PDU('A00831060101FF020105'O) == myValue)
36930 {setverdict(pass);} else {setverdict(fail);}
36935 Overall verdict: pass
36941 .*---------------------------------------------------------------------*
36942 :h3. DECODING CER , TAGGED SET (both elements are used)
36943 .*---------------------------------------------------------------------*
36946 <TC - DECODING CER , TAGGED SET (both elements are used)>
36963 b BOOLEAN OPTIONAL,
36971 import from TempA all;
36973 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
36976 const BERPDU myValue := {b := true,
36983 if (dec_BER_PDU('A08031800101FF02010500000000'O) == myValue)
36987 {setverdict(pass);} else {setverdict(fail);}
36992 Overall verdict: pass
36998 .*---------------------------------------------------------------------*
36999 :h3. DECODING , reverse order , TAGGED SEQUENCE (both elements are used)
37000 .*---------------------------------------------------------------------*
37003 <TC - DECODING , reverse order , TAGGED SEQUENCE (both elements are used)>
37018 BERPDU ::= [0] SEQUENCE
37020 b BOOLEAN OPTIONAL,
37028 import from TempA all;
37030 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37033 const BERPDU myValue := {b := true,
37040 if (dec_BER_PDU('A00831060101FF020105'O) == myValue)
37044 {setverdict(pass);} else {setverdict(fail);}
37049 Overall verdict: pass
37055 .*---------------------------------------------------------------------*
37056 :h3. DECODING , reverse order , TAGGED SET (both elements are used)
37057 .*---------------------------------------------------------------------*
37060 <TC - DECODING , reverse order , TAGGED SET (both elements are used)>
37077 b BOOLEAN OPTIONAL,
37085 import from TempA all;
37087 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37090 const BERPDU myValue := {b := true,
37097 if (dec_BER_PDU('A08031800201050101FF00000000'O) == myValue)
37101 {setverdict(pass);} else {setverdict(fail);}
37106 Overall verdict: pass
37112 .*---------------------------------------------------------------------*
37113 :h3. DECODING DER , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT
37114 .*---------------------------------------------------------------------*
37117 <TC - DECODING DER , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
37135 b BOOLEAN OPTIONAL,
37144 import from TempA all;
37146 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37149 const BERPDU myValue := {b := true,
37155 if (dec_BER_PDU('A0060101FF020105'O) == myValue)
37159 {setverdict(pass);} else {setverdict(fail);}
37164 Overall verdict: pass
37170 .*---------------------------------------------------------------------*
37171 :h3. DECODING CER , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT
37172 .*---------------------------------------------------------------------*
37175 <TC - DECODING CER , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
37193 b BOOLEAN OPTIONAL,
37202 import from TempA all;
37204 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37207 const BERPDU myValue := {b := true,
37213 if (dec_BER_PDU('A0800101FF0201050000'O) == myValue)
37217 {setverdict(pass);} else {setverdict(fail);}
37222 Overall verdict: pass
37228 .*---------------------------------------------------------------------*
37229 :h3. DECODING , reverse order , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT
37230 .*---------------------------------------------------------------------*
37233 <TC - DECODING , reverse order , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
37251 b BOOLEAN OPTIONAL,
37260 import from TempA all;
37262 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37265 const BERPDU myValue := {b := true,
37271 if (dec_BER_PDU('A0060201050101FF'O) == myValue)
37275 {setverdict(pass);} else {setverdict(fail);}
37280 Overall verdict: pass
37286 .*---------------------------------------------------------------------*
37287 :h3. DECODING, reverse order , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT
37288 .*---------------------------------------------------------------------*
37291 <TC - DECODING, reverse order , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT>
37309 b BOOLEAN OPTIONAL,
37318 import from TempA all;
37320 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37323 const BERPDU myValue := {b := true,
37329 if (dec_BER_PDU('A0800201050101FF0000'O) == myValue)
37333 {setverdict(pass);} else {setverdict(fail);}
37338 Overall verdict: pass
37344 .*---------------------------------------------------------------------*
37345 :h3. DECODING DER , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT
37346 .*---------------------------------------------------------------------*
37349 <TC - DECODING DER , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
37367 b BOOLEAN OPTIONAL,
37376 import from TempA all;
37378 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37381 const BERPDU myValue := {b := true,
37388 if (dec_BER_PDU('A00831060101FF020105'O) == myValue)
37392 {setverdict(pass);} else {setverdict(fail);}
37397 Overall verdict: pass
37403 .*---------------------------------------------------------------------*
37404 :h3. DECODING CER , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT
37405 .*---------------------------------------------------------------------*
37408 <TC - DECODING CER , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
37426 b BOOLEAN OPTIONAL,
37435 import from TempA all;
37437 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37440 const BERPDU myValue := {b := true,
37447 if (dec_BER_PDU('A08031800101FF02010500000000'O) == myValue)
37451 {setverdict(pass);} else {setverdict(fail);}
37456 Overall verdict: pass
37462 .*---------------------------------------------------------------------*
37463 :h3. DECODING, reverse order , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT
37464 .*---------------------------------------------------------------------*
37467 <TC - DECODING, reverse order , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
37485 b BOOLEAN OPTIONAL,
37494 import from TempA all;
37496 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37499 const BERPDU myValue := {b := true,
37506 if (dec_BER_PDU('A00831060201050101FF'O) == myValue)
37510 {setverdict(pass);} else {setverdict(fail);}
37515 Overall verdict: pass
37521 .*---------------------------------------------------------------------*
37522 :h3. DECODING, reverse order , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT
37523 .*---------------------------------------------------------------------*
37526 <TC - DECODING, reverse order , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT>
37544 b BOOLEAN OPTIONAL,
37553 import from TempA all;
37555 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37558 const BERPDU myValue := {b := true,
37565 if (dec_BER_PDU('A08031800201050101FF00000000'O) == myValue)
37569 {setverdict(pass);} else {setverdict(fail);}
37574 Overall verdict: pass
37580 .*---------------------------------------------------------------------*
37581 :h3. DECODING DER, TAGGED SET (both elements are TAGGED and used)
37582 .*---------------------------------------------------------------------*
37585 <TC - DECODING DER, TAGGED SET (both elements are TAGGED and used)>
37602 b [0] BOOLEAN OPTIONAL,
37603 c [1] INTEGER OPTIONAL
37612 import from TempA all;
37614 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37617 const BERPDU myValue := {b := true,
37624 if (dec_BER_PDU('A00C310AA0030101FFA103020105'O) == myValue)
37628 {setverdict(pass);} else {setverdict(fail);}
37633 Overall verdict: pass
37639 .*---------------------------------------------------------------------*
37640 :h3. DECODING CER, TAGGED SET (both elements are TAGGED and used)
37641 .*---------------------------------------------------------------------*
37644 <TC - DECODING CER, TAGGED SET (both elements are TAGGED and used)>
37661 b [0] BOOLEAN OPTIONAL,
37662 c [1] INTEGER OPTIONAL
37671 import from TempA all;
37673 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37676 const BERPDU myValue := {b := true,
37683 if (dec_BER_PDU('A0803180A0800101FF0000A180020105000000000000'O) == myValue)
37687 {setverdict(pass);} else {setverdict(fail);}
37692 Overall verdict: pass
37698 .*---------------------------------------------------------------------*
37699 :h3. DECODING reverse order, TAGGED SET (both elements are TAGGED and used)
37700 .*---------------------------------------------------------------------*
37703 <TC - DECODING reverse order, TAGGED SET (both elements are TAGGED and used)>
37720 b [0] BOOLEAN OPTIONAL,
37721 c [1] INTEGER OPTIONAL
37730 import from TempA all;
37732 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37735 const BERPDU myValue := {b := true,
37742 if (dec_BER_PDU('A00C310AA103020105A0030101FF'O) == myValue)
37746 {setverdict(pass);} else {setverdict(fail);}
37751 Overall verdict: pass
37757 .*---------------------------------------------------------------------*
37758 :h3. DECODING reverse order, TAGGED SET (both elements are TAGGED and used)
37759 .*---------------------------------------------------------------------*
37762 <TC - DECODING reverse order, TAGGED SET (both elements are TAGGED and used)>
37779 b [0] BOOLEAN OPTIONAL,
37780 c [1] INTEGER OPTIONAL
37789 import from TempA all;
37791 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37794 const BERPDU myValue := {b := true,
37801 if (dec_BER_PDU('A0803180A1800201050000A0800101FF000000000000'O) == myValue)
37805 {setverdict(pass);} else {setverdict(fail);}
37810 Overall verdict: pass
37816 .*---------------------------------------------------------------------*
37817 :h3. DECODING DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
37818 .*---------------------------------------------------------------------*
37821 <TC - DECODING DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
37839 b [0] BOOLEAN OPTIONAL,
37840 c [1] INTEGER OPTIONAL
37848 import from TempA all;
37850 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37853 const BERPDU myValue := {b := true,
37860 if (dec_BER_PDU('A00C310AA0030101FFA103020105'O) == myValue)
37864 {setverdict(pass);} else {setverdict(fail);}
37869 Overall verdict: pass
37875 .*---------------------------------------------------------------------*
37876 :h3. DECODING CER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
37877 .*---------------------------------------------------------------------*
37880 <TC - DECODING CER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
37898 b [0] BOOLEAN OPTIONAL,
37899 c [1] INTEGER OPTIONAL
37907 import from TempA all;
37909 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37912 const BERPDU myValue := {b := true,
37919 if (dec_BER_PDU('A0803180A0800101FF0000A180020105000000000000'O) == myValue)
37923 {setverdict(pass);} else {setverdict(fail);}
37928 Overall verdict: pass
37934 .*---------------------------------------------------------------------*
37935 :h3. DECODING ,reverse order, TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
37936 .*---------------------------------------------------------------------*
37939 <TC - DECODING ,reverse order, TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
37957 b [0] BOOLEAN OPTIONAL,
37958 c [1] INTEGER OPTIONAL
37966 import from TempA all;
37968 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
37971 const BERPDU myValue := {b := true,
37978 if (dec_BER_PDU('A00C310AA103020105A0030101FF'O) == myValue)
37982 {setverdict(pass);} else {setverdict(fail);}
37987 Overall verdict: pass
37993 .*---------------------------------------------------------------------*
37994 :h3. DECODING, reverse order, TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT
37995 .*---------------------------------------------------------------------*
37998 <TC - DECODING, reverse order, TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT>
38016 b [0] BOOLEAN OPTIONAL,
38017 c [1] INTEGER OPTIONAL
38025 import from TempA all;
38027 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38030 const BERPDU myValue := {b := true,
38037 if (dec_BER_PDU('A0803180A1800201050000A0800101FF000000000000'O) == myValue)
38041 {setverdict(pass);} else {setverdict(fail);}
38046 Overall verdict: pass
38052 .*---------------------------------------------------------------------*
38053 :h3. DECODING , DER , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
38054 .*---------------------------------------------------------------------*
38057 <TC - DECODING , DER , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
38075 b [0] BOOLEAN OPTIONAL,
38076 c [1] INTEGER OPTIONAL
38084 import from TempA all;
38086 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38089 const BERPDU myValue := {b := true,
38095 if (dec_BER_PDU('A0068001FF810105'O) == myValue)
38099 {setverdict(pass);} else {setverdict(fail);}
38104 Overall verdict: pass
38110 .*---------------------------------------------------------------------*
38111 :h3. DECODING , CER , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
38112 .*---------------------------------------------------------------------*
38115 <TC - DECODING , CER , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
38133 b [0] BOOLEAN OPTIONAL,
38134 c [1] INTEGER OPTIONAL
38142 import from TempA all;
38144 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38147 const BERPDU myValue := {b := true,
38153 if (dec_BER_PDU('A0808001FF8101050000'O) == myValue)
38157 {setverdict(pass);} else {setverdict(fail);}
38162 Overall verdict: pass
38168 .*---------------------------------------------------------------------*
38169 :h3. DECODING , reverse order, TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
38170 .*---------------------------------------------------------------------*
38173 <TC - DECODING , reverse order, TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
38191 b [0] BOOLEAN OPTIONAL,
38192 c [1] INTEGER OPTIONAL
38200 import from TempA all;
38202 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38205 const BERPDU myValue := {b := true,
38211 if (dec_BER_PDU('A0068101058001FF'O) == myValue)
38215 {setverdict(pass);} else {setverdict(fail);}
38220 Overall verdict: pass
38226 .*---------------------------------------------------------------------*
38227 :h3. DECODING , reverse order , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT
38228 .*---------------------------------------------------------------------*
38231 <TC - DECODING , reverse order , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT>
38249 b [0] BOOLEAN OPTIONAL,
38250 c [1] INTEGER OPTIONAL
38258 import from TempA all;
38260 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38263 const BERPDU myValue := {b := true,
38269 if (dec_BER_PDU('A0808101058001FF0000'O) == myValue)
38273 {setverdict(pass);} else {setverdict(fail);}
38278 Overall verdict: pass
38284 .*---------------------------------------------------------------------*
38285 :h3. DECODING , DER , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
38286 .*---------------------------------------------------------------------*
38289 <TC - DECODING , DER , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
38307 b [0] BOOLEAN OPTIONAL,
38308 c [1] INTEGER OPTIONAL
38316 import from TempA all;
38318 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38321 const BERPDU myValue := {b := true,
38327 if (dec_BER_PDU('A0068001FF810105'O) == myValue)
38331 {setverdict(pass);} else {setverdict(fail);}
38336 Overall verdict: pass
38342 .*---------------------------------------------------------------------*
38343 :h3. DECODING , CER , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
38344 .*---------------------------------------------------------------------*
38347 <TC - DECODING , CER , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
38365 b [0] BOOLEAN OPTIONAL,
38366 c [1] INTEGER OPTIONAL
38374 import from TempA all;
38376 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38379 const BERPDU myValue := {b := true,
38385 if (dec_BER_PDU('A0808001FF8101050000'O) == myValue)
38389 {setverdict(pass);} else {setverdict(fail);}
38394 Overall verdict: pass
38400 .*---------------------------------------------------------------------*
38401 :h3. DECODING , reverse order , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
38402 .*---------------------------------------------------------------------*
38405 <TC - DECODING , reverse order , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
38423 b [0] BOOLEAN OPTIONAL,
38424 c [1] INTEGER OPTIONAL
38432 import from TempA all;
38434 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38437 const BERPDU myValue := {b := true,
38443 if (dec_BER_PDU('A0068101058001FF'O) == myValue)
38447 {setverdict(pass);} else {setverdict(fail);}
38452 Overall verdict: pass
38458 .*---------------------------------------------------------------------*
38459 :h3. DECODING , reverse order, TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT
38460 .*---------------------------------------------------------------------*
38463 <TC - DECODING , reverse order, TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT>
38481 b [0] BOOLEAN OPTIONAL,
38482 c [1] INTEGER OPTIONAL
38490 import from TempA all;
38492 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38495 const BERPDU myValue := {b := true,
38501 if (dec_BER_PDU('A0808101058001FF0000'O) == myValue)
38505 {setverdict(pass);} else {setverdict(fail);}
38510 Overall verdict: pass
38516 .*---------------------------------------------------------------------*
38517 :h3. DECODING ,DER, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
38518 .*---------------------------------------------------------------------*
38521 <TC - DECODING ,DER, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
38539 b [5] BOOLEAN OPTIONAL,
38548 import from TempA all;
38550 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38553 const BERPDU myValue := {b := true,
38559 if (dec_BER_PDU('31060201058501FF'O) == myValue)
38563 {setverdict(pass);} else {setverdict(fail);}
38568 Overall verdict: pass
38574 .*---------------------------------------------------------------------*
38575 :h3. DECODING ,CER, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
38576 .*---------------------------------------------------------------------*
38579 <TC - DECODING ,CER, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
38597 b [5] BOOLEAN OPTIONAL,
38606 import from TempA all;
38608 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38611 const BERPDU myValue := {b := true,
38617 if (dec_BER_PDU('31800201058501FF0000'O) == myValue)
38621 {setverdict(pass);} else {setverdict(fail);}
38626 Overall verdict: pass
38632 .*---------------------------------------------------------------------*
38633 :h3. DECODING ,reverse order, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
38634 .*---------------------------------------------------------------------*
38637 <TC - DECODING ,reverse order, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
38655 b [5] BOOLEAN OPTIONAL,
38664 import from TempA all;
38666 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38669 const BERPDU myValue := {b := true,
38675 if (dec_BER_PDU('31068501FF020105'O) == myValue)
38679 {setverdict(pass);} else {setverdict(fail);}
38684 Overall verdict: pass
38690 .*---------------------------------------------------------------------*
38691 :h3. DECODING ,reverse order, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT
38692 .*---------------------------------------------------------------------*
38695 <TC - DECODING ,reverse order, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT>
38713 b [5] BOOLEAN OPTIONAL,
38722 import from TempA all;
38724 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38727 const BERPDU myValue := {b := true,
38733 if (dec_BER_PDU('31808501FF0201050000'O) == myValue)
38737 {setverdict(pass);} else {setverdict(fail);}
38742 Overall verdict: pass
38748 .*---------------------------------------------------------------------*
38749 :h3. DECODING ,DER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
38750 .*---------------------------------------------------------------------*
38753 <TC - DECODING ,DER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
38769 {x INTEGER OPTIONAL,
38776 b BOOLEAN OPTIONAL,
38777 c INTEGER OPTIONAL,
38778 COMPONENTS OF MySeq
38786 import from TempA all;
38788 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38791 const BERPDU myValue := {b := true,
38800 if (dec_BER_PDU('310C8001FF8101058201068301FF'O) == myValue)
38804 {setverdict(pass);} else {setverdict(fail);}
38809 Overall verdict: pass
38815 .*---------------------------------------------------------------------*
38816 :h3. DECODING ,CER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
38817 .*---------------------------------------------------------------------*
38820 <TC - DECODING ,CER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
38837 {x INTEGER OPTIONAL,
38844 b BOOLEAN OPTIONAL,
38845 c INTEGER OPTIONAL,
38846 COMPONENTS OF MySeq
38854 import from TempA all;
38856 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38858 const BERPDU myValue := {b := true,
38868 if (dec_BER_PDU('31808001FF8101058201068301FF0000'O) == myValue){setverdict(pass);} else {setverdict(fail);}
38873 Overall verdict: pass
38879 .*---------------------------------------------------------------------*
38880 :h3. DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
38881 .*---------------------------------------------------------------------*
38884 <TC - DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
38900 {x INTEGER OPTIONAL,
38907 b BOOLEAN OPTIONAL,
38908 c INTEGER OPTIONAL,
38909 COMPONENTS OF MySeq
38917 import from TempA all;
38919 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38922 const BERPDU myValue := {b := true,
38931 if (dec_BER_PDU('310C8001FF8201068101058301FF'O) == myValue)
38935 {setverdict(pass);} else {setverdict(fail);}
38940 Overall verdict: pass
38946 .*---------------------------------------------------------------------*
38947 :h3. DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
38948 .*---------------------------------------------------------------------*
38951 <TC - DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
38968 {x INTEGER OPTIONAL,
38975 b BOOLEAN OPTIONAL,
38976 c INTEGER OPTIONAL,
38977 COMPONENTS OF MySeq
38985 import from TempA all;
38987 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
38989 const BERPDU myValue := {b := true,
38999 if (dec_BER_PDU('31808001FF8201068101058301FF0000'O) == myValue)
39003 {setverdict(pass);} else {setverdict(fail);}
39008 Overall verdict: pass
39014 .*---------------------------------------------------------------------*
39015 :h3. DECODING ,DER, SET ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39016 .*---------------------------------------------------------------------*
39019 <TC - DECODING ,DER, SET ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39035 {x [0] INTEGER OPTIONAL,
39042 b BOOLEAN OPTIONAL,
39043 c INTEGER OPTIONAL,
39044 COMPONENTS OF MySeq
39053 import from TempA all;
39055 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39058 const BERPDU myValue := {b := true,
39067 if (dec_BER_PDU('310C8001FF8101058201068301FF'O) == myValue)
39071 {setverdict(pass);} else {setverdict(fail);}
39076 Overall verdict: pass
39082 .*---------------------------------------------------------------------*
39083 :h3. DECODING ,CER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
39084 .*---------------------------------------------------------------------*
39087 <TC - DECODING ,CER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
39104 {x [0] INTEGER OPTIONAL,
39111 b BOOLEAN OPTIONAL,
39112 c INTEGER OPTIONAL,
39113 COMPONENTS OF MySeq
39123 import from TempA all;
39125 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39128 const BERPDU myValue := {b := true,
39137 if (dec_BER_PDU('31808001FF8101058201068301FF0000'O) == myValue)
39141 {setverdict(pass);} else {setverdict(fail);}
39146 Overall verdict: pass
39152 .*---------------------------------------------------------------------*
39153 :h3. DECODING ,different order, SET ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39154 .*---------------------------------------------------------------------*
39157 <TC - DECODING ,different order, SET ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39173 {x [0] INTEGER OPTIONAL,
39180 b BOOLEAN OPTIONAL,
39181 c INTEGER OPTIONAL,
39182 COMPONENTS OF MySeq
39191 import from TempA all;
39193 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39196 const BERPDU myValue := {b := true,
39205 if (dec_BER_PDU('310C8301FF8001FF820106810105'O) == myValue)
39209 {setverdict(pass);} else {setverdict(fail);}
39214 Overall verdict: pass
39220 .*---------------------------------------------------------------------*
39221 :h3. DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags
39222 .*---------------------------------------------------------------------*
39225 <TC - DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags>
39242 {x [0] INTEGER OPTIONAL,
39249 b BOOLEAN OPTIONAL,
39250 c INTEGER OPTIONAL,
39251 COMPONENTS OF MySeq
39261 import from TempA all;
39263 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39266 const BERPDU myValue := {b := true,
39275 if (dec_BER_PDU('31808301FF8101058201068001FF0000'O) == myValue)
39279 {setverdict(pass);} else {setverdict(fail);}
39284 Overall verdict: pass
39290 .*---------------------------------------------------------------------*
39291 :h3. DECODING ,DER, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39292 .*---------------------------------------------------------------------*
39295 <TC - DECODING ,DER, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39312 {x INTEGER OPTIONAL,
39319 b [0] BOOLEAN OPTIONAL,
39320 c BIT STRING OPTIONAL,
39321 COMPONENTS OF MySeq
39328 import from TempA all;
39330 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39334 const BERPDU myValue := {b := true,
39342 if (dec_BER_PDU('310D020106030207800401FF8001FF'O) == myValue)
39345 {setverdict(pass);} else {setverdict(fail);}
39350 Overall verdict: pass
39356 .*---------------------------------------------------------------------*
39357 :h3. DECODING ,CER, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39358 .*---------------------------------------------------------------------*
39361 <TC - DECODING ,CER, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39378 {x INTEGER OPTIONAL,
39385 b [0] BOOLEAN OPTIONAL,
39386 c BIT STRING OPTIONAL,
39387 COMPONENTS OF MySeq
39397 import from TempA all;
39399 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39402 const BERPDU myValue := {b := true,
39410 if (dec_BER_PDU('3180020106030207800401FF8001FF0000'O) == myValue)
39414 {setverdict(pass);} else {setverdict(fail);}
39419 Overall verdict: pass
39425 .*---------------------------------------------------------------------*
39426 :h3. DECODING ,different order, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39427 .*---------------------------------------------------------------------*
39430 <TC - DECODING ,different order, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39447 {x INTEGER OPTIONAL,
39454 b [0] BOOLEAN OPTIONAL,
39455 c BIT STRING OPTIONAL,
39456 COMPONENTS OF MySeq
39463 import from TempA all;
39465 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39469 const BERPDU myValue := {b := true,
39477 if (dec_BER_PDU('310D030207800201060401FF8001FF'O) == myValue)
39481 {setverdict(pass);} else {setverdict(fail);}
39486 Overall verdict: pass
39492 .*---------------------------------------------------------------------*
39493 :h3. DECODING ,different order, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39494 .*---------------------------------------------------------------------*
39497 <TC - DECODING ,different order, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39514 {x INTEGER OPTIONAL,
39521 b [0] BOOLEAN OPTIONAL,
39522 c BIT STRING OPTIONAL,
39523 COMPONENTS OF MySeq
39533 import from TempA all;
39535 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39538 const BERPDU myValue := {b := true,
39546 if (dec_BER_PDU('3180030207800201060401FF8001FF0000'O) == myValue)
39550 {setverdict(pass);} else {setverdict(fail);}
39555 Overall verdict: pass
39561 .*---------------------------------------------------------------------*
39562 :h3. DECODING ,DER, SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39563 .*---------------------------------------------------------------------*
39566 <TC - DECODING ,DER, SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39583 {x [1] INTEGER OPTIONAL,
39590 b [0] BOOLEAN OPTIONAL,
39591 c BIT STRING OPTIONAL,
39592 COMPONENTS OF MySeq
39599 import from TempA all;
39601 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39605 const BERPDU myValue := {b := true,
39614 if (dec_BER_PDU('310D030207800401FF8001FF810106'O) == myValue)
39618 {setverdict(pass);} else {setverdict(fail);}
39623 Overall verdict: pass
39629 .*---------------------------------------------------------------------*
39630 :h3. DECODING ,CER, SET, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39631 .*---------------------------------------------------------------------*
39634 <TC - DECODING ,CER, SET, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39651 {x [1] INTEGER OPTIONAL,
39658 b [0] BOOLEAN OPTIONAL,
39659 c BIT STRING OPTIONAL,
39660 COMPONENTS OF MySeq
39670 import from TempA all;
39672 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39675 const BERPDU myValue := {b := true,
39684 if (dec_BER_PDU('3180030207800401FF8001FF8101060000'O) == myValue)
39688 {setverdict(pass);} else {setverdict(fail);}
39693 Overall verdict: pass
39699 .*---------------------------------------------------------------------*
39700 :h3. DECODING ,different order, SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39701 .*---------------------------------------------------------------------*
39704 <TC - DECODING ,different order, SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39721 {x [1] INTEGER OPTIONAL,
39728 b [0] BOOLEAN OPTIONAL,
39729 c BIT STRING OPTIONAL,
39730 COMPONENTS OF MySeq
39737 import from TempA all;
39739 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39743 const BERPDU myValue := {b := true,
39752 if (dec_BER_PDU('310D8101060401FF8001FF03020780'O) == myValue)
39756 {setverdict(pass);} else {setverdict(fail);}
39761 Overall verdict: pass
39767 .*---------------------------------------------------------------------*
39768 :h3. DECODING ,different order, SET, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS
39769 .*---------------------------------------------------------------------*
39772 <TC - DECODING ,different order, SET, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS>
39789 {x [1] INTEGER OPTIONAL,
39796 b [0] BOOLEAN OPTIONAL,
39797 c BIT STRING OPTIONAL,
39798 COMPONENTS OF MySeq
39808 import from TempA all;
39810 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39813 const BERPDU myValue := {b := true,
39822 if (dec_BER_PDU('31808001FF0401FF030207808101060000'O) == myValue)
39826 {setverdict(pass);} else {setverdict(fail);}
39831 Overall verdict: pass
39837 .*---------------------------------------------------------------------*
39838 :h3. DECODING ,DER, SET with CHOICE element, AUTOMATIC TAGS
39839 .*---------------------------------------------------------------------*
39842 <TC - DECODING ,DER, SET with CHOICE element, AUTOMATIC TAGS>
39877 import from TempA all;
39879 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39882 const BERPDU myValue := {b := {x := true},
39890 if (dec_BER_PDU('3108A0038001FF810104'O) == myValue)
39894 {setverdict(pass);} else {setverdict(fail);}
39899 Overall verdict: pass
39905 .*---------------------------------------------------------------------*
39906 :h3. DECODING ,CER, SET with CHOICE element, AUTOMATIC TAGS
39907 .*---------------------------------------------------------------------*
39910 <TC - DECODING ,CER, SET with CHOICE element, AUTOMATIC TAGS>
39943 import from TempA all;
39945 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
39948 const BERPDU myValue := {b := {x := true},
39955 if (dec_BER_PDU('3180A0808001FF00008101040000'O) == myValue)
39959 {setverdict(pass);} else {setverdict(fail);}
39964 Overall verdict: pass
39970 .*---------------------------------------------------------------------*
39971 :h3. DECODING ,reverse order, SET with CHOICE element, AUTOMATIC TAGS
39972 .*---------------------------------------------------------------------*
39975 <TC - DECODING ,reverse order, SET with CHOICE element, AUTOMATIC TAGS>
40010 import from TempA all;
40012 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40015 const BERPDU myValue := {b := {x := true},
40023 if (dec_BER_PDU('3108810104A0038001FF'O) == myValue)
40027 {setverdict(pass);} else {setverdict(fail);}
40032 Overall verdict: pass
40038 .*---------------------------------------------------------------------*
40039 :h3. DECODING ,reverse order, SET with CHOICE element, AUTOMATIC TAGS
40040 .*---------------------------------------------------------------------*
40043 <TC - DECODING ,reverse order, SET with CHOICE element, AUTOMATIC TAGS>
40076 import from TempA all;
40078 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40081 const BERPDU myValue := {b := {x := true},
40088 if (dec_BER_PDU('3180810104A0808001FF00000000'O) == myValue)
40092 {setverdict(pass);} else {setverdict(fail);}
40097 Overall verdict: pass
40103 .*---------------------------------------------------------------------*
40104 :h3. DECODING ,DER, SET with CHOICE element,
40105 .*---------------------------------------------------------------------*
40108 <TC - DECODING ,DER, SET with CHOICE element, >
40141 import from TempA all;
40143 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40145 const BERPDU myValue := {b := {x := true},
40153 if (dec_BER_PDU('31060101FF020104'O) == myValue) {setverdict(pass);} else {setverdict(fail);}
40158 Overall verdict: pass
40164 .*---------------------------------------------------------------------*
40165 :h3. DECODING ,CER, SET with CHOICE element,
40166 .*---------------------------------------------------------------------*
40169 <TC - DECODING ,CER, SET with CHOICE element, >
40201 import from TempA all;
40203 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40206 const BERPDU myValue := {b := {x := true},
40213 if (dec_BER_PDU('31800101FF0201040000'O) == myValue){setverdict(pass);} else {setverdict(fail);}
40218 Overall verdict: pass
40224 .*---------------------------------------------------------------------*
40225 :h3. DECODING ,reverse order, SET with CHOICE element,
40226 .*---------------------------------------------------------------------*
40229 <TC - DECODING ,reverse order, SET with CHOICE element, >
40262 import from TempA all;
40264 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40266 const BERPDU myValue := {b := {x := true},
40274 if (dec_BER_PDU('31060201040101FF'O) == myValue)
40278 {setverdict(pass);} else {setverdict(fail);}
40283 Overall verdict: pass
40289 .*---------------------------------------------------------------------*
40290 :h3. DECODING ,reverse order, SET with CHOICE element,
40291 .*---------------------------------------------------------------------*
40294 <TC - DECODING ,reverse order, SET with CHOICE element, >
40326 import from TempA all;
40328 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40331 const BERPDU myValue := {b := {x := true},
40338 if (dec_BER_PDU('31800201040101FF0000'O) == myValue)
40342 {setverdict(pass);} else {setverdict(fail);}
40347 Overall verdict: pass
40353 .*---------------------------------------------------------------------*
40354 :h3. DECODING DER, SET with CHOICE element, different choice
40355 .*---------------------------------------------------------------------*
40358 <TC - DECODING DER, SET with CHOICE element, different choice >
40390 import from TempA all;
40392 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40395 const BERPDU myValue := {b := {y := 'FF'O},
40402 if (dec_BER_PDU('31060201040401FF'O) == myValue)
40406 {setverdict(pass);} else {setverdict(fail);}
40411 Overall verdict: pass
40417 .*---------------------------------------------------------------------*
40418 :h3. DECODING CER, SET with CHOICE element, different choice
40419 .*---------------------------------------------------------------------*
40422 <TC - DECODING CER, SET with CHOICE element, different choice >
40454 import from TempA all;
40456 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40459 const BERPDU myValue := {b := {y := 'FF'O},
40466 if (dec_BER_PDU('31800401FF0201040000'O) == myValue)
40470 {setverdict(pass);} else {setverdict(fail);}
40475 Overall verdict: pass
40481 .*---------------------------------------------------------------------*
40482 :h3. DECODING , SET with CHOICE element, different choice
40483 .*---------------------------------------------------------------------*
40486 <TC - DECODING , SET with CHOICE element, different choice >
40518 import from TempA all;
40520 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40523 const BERPDU myValue := {b := {y := 'FF'O},
40530 if (dec_BER_PDU('31060401FF020104'O) == myValue)
40534 {setverdict(pass);} else {setverdict(fail);}
40539 Overall verdict: pass
40545 .*---------------------------------------------------------------------*
40546 :h3. DECODING , SET with CHOICE element, different choice
40547 .*---------------------------------------------------------------------*
40550 <TC - DECODING , SET with CHOICE element, different choice >
40582 import from TempA all;
40584 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40587 const BERPDU myValue := {b := {y := 'FF'O},
40594 if (dec_BER_PDU('31800201040401FF0000'O) == myValue)
40598 {setverdict(pass);} else {setverdict(fail);}
40603 Overall verdict: pass
40609 .*---------------------------------------------------------------------*
40610 :h3. DECODING ,DER, SET with EXTENSION , AUTOMATIC TAGS
40611 .*---------------------------------------------------------------------*
40614 <TC - DECODING ,DER, SET with EXTENSION , AUTOMATIC TAGS>
40637 c INTEGER OPTIONAL,
40652 import from TempA all;
40654 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40657 const BERPDU myValue := {
40666 if (dec_BER_PDU('310D8001FF8101FF82010483020780'O) == myValue)
40670 {setverdict(pass);} else {setverdict(fail);}
40675 Overall verdict: pass
40681 .*---------------------------------------------------------------------*
40682 :h3. DECODING ,CER, SET with EXTENSION , AUTOMATIC TAGS
40683 .*---------------------------------------------------------------------*
40686 <TC - DECODING ,CER, SET with EXTENSION , AUTOMATIC TAGS>
40709 c INTEGER OPTIONAL,
40722 import from TempA all;
40724 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40727 const BERPDU myValue := {
40736 if (dec_BER_PDU('31808001FF8101FF820104830207800000'O) == myValue)
40740 {setverdict(pass);} else {setverdict(fail);}
40745 Overall verdict: pass
40751 .*---------------------------------------------------------------------*
40752 :h3. DECODING ,different order, SET with EXTENSION , AUTOMATIC TAGS
40753 .*---------------------------------------------------------------------*
40756 <TC - DECODING ,different order, SET with EXTENSION , AUTOMATIC TAGS>
40779 c INTEGER OPTIONAL,
40794 import from TempA all;
40796 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40799 const BERPDU myValue := {
40808 if (dec_BER_PDU('310D8001FF830207808101FF820104'O) == myValue)
40812 {setverdict(pass);} else {setverdict(fail);}
40817 Overall verdict: pass
40823 .*---------------------------------------------------------------------*
40824 :h3. DECODING ,different order, SET with EXTENSION , AUTOMATIC TAGS
40825 .*---------------------------------------------------------------------*
40828 <TC - DECODING ,different order, SET with EXTENSION , AUTOMATIC TAGS>
40851 c INTEGER OPTIONAL,
40864 import from TempA all;
40866 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40869 const BERPDU myValue := {
40878 if (dec_BER_PDU('31808001FF830207808101FF8201040000'O) == myValue)
40882 {setverdict(pass);} else {setverdict(fail);}
40887 Overall verdict: pass
40893 .*---------------------------------------------------------------------*
40894 :h3. DECODING SET with Long Form , AUTOMATIC TAGS
40895 .*---------------------------------------------------------------------*
40898 <TC - DECODING SET with Long Form , AUTOMATIC TAGS>
40921 c INTEGER OPTIONAL,
40936 import from TempA all;
40938 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
40941 const BERPDU myValue := {
40950 if (dec_BER_PDU('318300000D8001FF8101FF82010483020780'O) == myValue)
40954 {setverdict(pass);} else {setverdict(fail);}
40959 Overall verdict: pass
40965 .*---------------------------------------------------------------------*
40966 :h3. DECODING, different order, SET with Long Form , AUTOMATIC TAGS
40967 .*---------------------------------------------------------------------*
40970 <TC - DECODING, different order, SET with Long Form , AUTOMATIC TAGS>
40993 c INTEGER OPTIONAL,
41008 import from TempA all;
41010 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41013 const BERPDU myValue := {
41022 if (dec_BER_PDU('318300000D8101FF820104830207808001FF'O) == myValue)
41026 {setverdict(pass);} else {setverdict(fail);}
41031 Overall verdict: pass
41037 .*---------------------------------------------------------------------*
41038 :h3. DECODING , DER, SET with fields of different types ,
41039 .*---------------------------------------------------------------------*
41042 <TC - DECODING , DER, SET with fields of different types ,>
41061 d ENUMERATED {first ,second ,third},
41066 h OBJECT IDENTIFIER,
41068 j CHOICE {x1 [1] BOOLEAN,
41069 y1 [2] OCTET STRING},
41071 k SEQUENCE{x2 NULL,
41074 l SET { x3 BIT STRING,
41077 m [3] SEQUENCE OF INTEGER,
41078 n [4] SET OF BOOLEAN
41082 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41089 import from TempA all;
41091 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41094 const BERPDU myValue := {a := NULL,
41103 j := {x1 := true } ,
41122 if (dec_BER_PDU('31450101FF020102030207800402FFFF050006030002030A01001603414243300505000101FF3106030207800500A1030101FFA3083006020101020102A40831060101FF0101FF'O) == myValue)
41126 {setverdict(pass);} else {setverdict(fail);}
41131 Overall verdict: pass
41137 .*---------------------------------------------------------------------*
41138 :h3. DECODING , CER, SET with fields of different types ,
41139 .*---------------------------------------------------------------------*
41142 <TC - DECODING , CER, SET with fields of different types ,>
41161 d ENUMERATED {first ,second ,third},
41166 h OBJECT IDENTIFIER,
41168 j CHOICE {x1 [1] BOOLEAN,
41169 y1 [2] OCTET STRING},
41171 k SEQUENCE{x2 NULL,
41174 l SET { x3 BIT STRING,
41177 m [3] SEQUENCE OF INTEGER,
41178 n [4] SET OF BOOLEAN
41182 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41189 import from TempA all;
41191 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41194 const BERPDU myValue := {a := NULL,
41198 // e := 1.0, 090603312E452B30
41203 j := {x1 := true } ,
41222 if (dec_BER_PDU('31800101FF020102030207800402FFFF050006030002030A01001603414243308005000101FF000031800302078005000000A1800101FF0000A380308002010102010200000000A48031800101FF0101FF000000000000'O) == myValue)
41226 {setverdict(pass);} else {setverdict(fail);}
41231 Overall verdict: pass
41237 .*---------------------------------------------------------------------*
41238 :h3. DECODING , different order, SET with fields of different types , different order
41239 .*---------------------------------------------------------------------*
41242 <TC - DECODING , different order, SET with fields of different types , different order >
41261 d ENUMERATED {first ,second ,third},
41266 h OBJECT IDENTIFIER,
41268 j CHOICE {x1 [1] BOOLEAN,
41269 y1 [2] OCTET STRING},
41271 k SEQUENCE{x2 NULL,
41274 l SET { x3 BIT STRING,
41277 m [3] SEQUENCE OF INTEGER,
41278 n [4] SET OF BOOLEAN
41282 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41289 import from TempA all;
41291 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41294 const BERPDU myValue := {a := NULL,
41303 j := {x1 := true } ,
41322 if (dec_BER_PDU('31450101FF0201020A0100030207800402FFFF06030002031603414243A1030101FF300505000101FF3106030207800500A3083006020101020102A40831060101FF0101FF0500'O) == myValue)
41326 {setverdict(pass);} else {setverdict(fail);}
41331 Overall verdict: pass
41337 .*---------------------------------------------------------------------*
41338 :h3. DECODING , different order, SET with fields of different types , different order2
41339 .*---------------------------------------------------------------------*
41342 <TC - DECODING , different order, SET with fields of different types , different order2>
41361 d ENUMERATED {first ,second ,third},
41366 h OBJECT IDENTIFIER,
41368 j CHOICE {x1 [1] BOOLEAN,
41369 y1 [2] OCTET STRING},
41371 k SEQUENCE{x2 NULL,
41374 l SET { x3 BIT STRING,
41377 m [3] SEQUENCE OF INTEGER,
41378 n [4] SET OF BOOLEAN
41382 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41389 import from TempA all;
41391 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41394 const BERPDU myValue := {a := NULL,
41398 // e := 1.0, 090603312E452B30
41403 j := {x1 := true } ,
41422 if (dec_BER_PDU('31800101FF0201020A0100030207800402FFFF050006030002031603414243A1800101FF0000308005000101FF000031800302078005000000A380308002010102010200000000A48031800101FF0101FF000000000000'O) == myValue)
41426 {setverdict(pass);} else {setverdict(fail);}
41431 Overall verdict: pass
41437 .*---------------------------------------------------------------------*
41438 :h3. DECODING , DER, SET with fields of different types , AUTOMATIC TAGS
41439 .*---------------------------------------------------------------------*
41442 <TC - DECODING , DER, SET with fields of different types , AUTOMATIC TAGS>
41462 d ENUMERATED {first ,second ,third},
41467 h OBJECT IDENTIFIER,
41469 j CHOICE {x1 BOOLEAN,
41472 k SEQUENCE{x2 NULL,
41475 l SET { x3 BIT STRING,
41478 m SEQUENCE OF INTEGER,
41481 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41488 import from TempA all;
41490 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41493 const BERPDU myValue := {a := NULL,
41502 j := {x1 := true } ,
41522 if (dec_BER_PDU('314380008101FF8201028301008400850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB06800207808100AC06020101020102AD060101FF0101FF'O) == myValue)
41526 {setverdict(pass);} else {setverdict(fail);}
41531 Overall verdict: pass
41537 .*---------------------------------------------------------------------*
41538 :h3. DECODING , DER, SET with fields of different types ,AUTOMATIC TAGS
41539 .*---------------------------------------------------------------------*
41542 <TC - DECODING , DER, SET with fields of different types ,AUTOMATIC TAGS>
41561 d ENUMERATED {first ,second ,third},
41566 h OBJECT IDENTIFIER,
41568 j CHOICE {x1 BOOLEAN,
41571 k SEQUENCE{x2 NULL,
41574 l SET { x3 BIT STRING,
41577 m SEQUENCE OF INTEGER,
41580 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41588 import from TempA all;
41590 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41593 const BERPDU myValue := {a := NULL,
41602 j := {x1 := true } ,
41622 if (dec_BER_PDU('318080008101FF8201028301008400850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB808002078081000000AC800201010201020000AD800101FF0101FF00000000'O) == myValue)
41626 {setverdict(pass);} else {setverdict(fail);}
41631 Overall verdict: pass
41637 .*---------------------------------------------------------------------*
41638 :h3. DECODING , different order, SET with fields of different types , AUTOMATIC TAGS
41639 .*---------------------------------------------------------------------*
41642 <TC - DECODING , different order, SET with fields of different types , AUTOMATIC TAGS>
41662 d ENUMERATED {first ,second ,third},
41667 h OBJECT IDENTIFIER,
41669 j CHOICE {x1 BOOLEAN,
41672 k SEQUENCE{x2 NULL,
41675 l SET { x3 BIT STRING,
41678 m SEQUENCE OF INTEGER,
41681 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41688 import from TempA all;
41690 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41693 const BERPDU myValue := {a := NULL,
41702 j := {x1 := true } ,
41722 if (dec_BER_PDU('31438101FF8201028301008400850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB06800207808100AC06020101020102AD060101FF0101FF8000'O) == myValue)
41726 {setverdict(pass);} else {setverdict(fail);}
41731 Overall verdict: pass
41737 .*---------------------------------------------------------------------*
41738 :h3. DECODING , different order, SET with fields of different types ,AUTOMATIC TAGS
41739 .*---------------------------------------------------------------------*
41742 <TC - DECODING , different order, SET with fields of different types ,AUTOMATIC TAGS>
41761 d ENUMERATED {first ,second ,third},
41766 h OBJECT IDENTIFIER,
41768 j CHOICE {x1 BOOLEAN,
41771 k SEQUENCE{x2 NULL,
41774 l SET { x3 BIT STRING,
41777 m SEQUENCE OF INTEGER,
41780 myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)}
41788 import from TempA all;
41790 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41793 const BERPDU myValue := {a := NULL,
41802 j := {x1 := true } ,
41822 if (dec_BER_PDU('318080008201028101FF8301008400850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB808002078081000000AC800201010201020000AD800101FF0101FF00000000'O) == myValue)
41826 {setverdict(pass);} else {setverdict(fail);}
41831 Overall verdict: pass
41837 .*---------------------------------------------------------------------*
41838 :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGS
41839 .*---------------------------------------------------------------------*
41842 <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGS>
41859 d [PRIVATE 0] INTEGER OPTIONAL,
41860 a INTEGER OPTIONAL,
41861 b [APPLICATION 0] INTEGER OPTIONAL,
41862 c [0] INTEGER OPTIONAL
41872 import from TempA all;
41874 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41877 const BERPDU myValue := {
41887 if (dec_BER_PDU('310C020101400102800103C00104'O) == myValue)
41889 {setverdict(pass);} else {setverdict(fail);}
41894 Overall verdict: pass
41900 .*---------------------------------------------------------------------*
41901 :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGS
41902 .*---------------------------------------------------------------------*
41905 <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGS>
41922 d [PRIVATE 0] INTEGER OPTIONAL,
41923 a INTEGER OPTIONAL,
41924 b [APPLICATION 0] INTEGER OPTIONAL,
41925 c [0] INTEGER OPTIONAL
41935 import from TempA all;
41937 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41940 const BERPDU myValue := {
41950 if (dec_BER_PDU('3180020101400102800103C001040000'O) == myValue)
41952 {setverdict(pass);} else {setverdict(fail);}
41957 Overall verdict: pass
41963 .*---------------------------------------------------------------------*
41964 :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )
41965 .*---------------------------------------------------------------------*
41968 <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )>
41981 d [PRIVATE 0] INTEGER OPTIONAL,
41982 a INTEGER OPTIONAL,
41983 b [APPLICATION 0] INTEGER OPTIONAL,
41984 c [0] INTEGER OPTIONAL
41994 import from TempA all;
41996 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
41999 const BERPDU myValue := {
42009 if (dec_BER_PDU('31120201016003020102A003020103E003020104'O) == myValue)
42011 {setverdict(pass);} else {setverdict(fail);}
42016 Overall verdict: pass
42022 .*---------------------------------------------------------------------*
42023 :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )
42024 .*---------------------------------------------------------------------*
42027 <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )>
42040 d [PRIVATE 0] INTEGER OPTIONAL,
42041 a INTEGER OPTIONAL,
42042 b [APPLICATION 0] INTEGER OPTIONAL,
42043 c [0] INTEGER OPTIONAL
42053 import from TempA all;
42055 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
42058 const BERPDU myValue := {
42068 if (dec_BER_PDU('318002010160800201020000A0800201030000E08002010400000000'O) == myValue)
42070 {setverdict(pass);} else {setverdict(fail);}
42075 Overall verdict: pass
42081 .*---------------------------------------------------------------------*
42082 :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGS
42083 .*---------------------------------------------------------------------*
42086 <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGS>
42105 d [PRIVATE 0] INTEGER OPTIONAL,
42106 a INTEGER OPTIONAL,
42107 b [APPLICATION 0] INTEGER OPTIONAL,
42108 c [0] INTEGER OPTIONAL
42118 import from TempA all;
42120 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
42123 const BERPDU myValue := {
42133 if (dec_BER_PDU('31120201016003020102A003020103E003020104'O) == myValue)
42135 {setverdict(pass);} else {setverdict(fail);}
42140 Overall verdict: pass
42146 .*---------------------------------------------------------------------*
42147 :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGGING
42148 .*---------------------------------------------------------------------*
42151 <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGGING>
42169 d [PRIVATE 0] INTEGER OPTIONAL,
42170 a INTEGER OPTIONAL,
42171 b [APPLICATION 0] INTEGER OPTIONAL,
42172 c [0] INTEGER OPTIONAL
42182 import from TempA all;
42184 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
42187 const BERPDU myValue := {
42197 if (dec_BER_PDU('318002010160800201020000A0800201030000E08002010400000000'O) == myValue)
42199 {setverdict(pass);} else {setverdict(fail);}
42204 Overall verdict: pass
42210 .*---------------------------------------------------------------------*
42211 :h3. DECODING SET, DER, untagged CHOICE in SET
42212 .*---------------------------------------------------------------------*
42215 <TC - DECODING SET, DER, untagged CHOICE in SET>
42264 import from TempA all;
42266 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
42271 const BERPDU myValue := {
42274 e := { f := {g := 3 }}
42281 if (dec_BER_PDU('310BA103820102830101850103'O) == myValue)
42283 {setverdict(pass);} else {setverdict(fail);}
42288 Overall verdict: pass
42294 .*---------------------------------------------------------------------*
42295 :h3. DECODING SET, CER, untagged CHOICE in SET
42296 .*---------------------------------------------------------------------*
42299 <TC - DECODING SET, CER, untagged CHOICE in SET>
42348 import from TempA all;
42350 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
42355 const BERPDU myValue := {
42358 e := { f := {g := 3 }}
42365 if (dec_BER_PDU('3180850103A18082010200008301010000'O) == myValue)
42367 {setverdict(pass);} else {setverdict(fail);}
42372 Overall verdict: pass
42378 .*---------------------------------------------------------------------*
42379 :h3. DECODING SET, DER, untagged CHOICE in SET, EXPLICIT TAGS
42380 .*---------------------------------------------------------------------*
42383 <TC - DECODING SET, DER, untagged CHOICE in SET, EXPLICIT TAGS>
42432 import from TempA all;
42434 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
42439 const BERPDU myValue := {
42442 e := { f := {g := 3 }}
42449 if (dec_BER_PDU('3111A105A203020102A303020101A503020103'O) == myValue)
42451 {setverdict(pass);} else {setverdict(fail);}
42456 Overall verdict: pass
42462 .*---------------------------------------------------------------------*
42463 :h3. DECODING SET, CER, untagged CHOICE in SET, EXPLICIT TAGS
42464 .*---------------------------------------------------------------------*
42467 <TC - DECODING SET, CER, untagged CHOICE in SET, EXPLICIT TAGS>
42516 import from TempA all;
42518 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
42523 const BERPDU myValue := {
42526 e := { f := {g := 3 }}
42533 if (dec_BER_PDU('3180A5800201030000A180A28002010200000000A38002010100000000'O) == myValue)
42535 {setverdict(pass);} else {setverdict(fail);}
42540 Overall verdict: pass
42546 .*---------------------------------------------------------------------*
42547 :h3.CER + DER encoding of SET OF INTEGER (empty)
42548 .*---------------------------------------------------------------------*
42551 <TC - CER + DER encoding of SET OF INTEGER (empty)>
42560 BERPDU ::= SET OF INTEGER
42568 import from TempA all;
42569 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42570 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42572 const BERPDU myValue := { }
42579 if ((enc_DER_PDU(myValue) == '3100'O)and(enc_CER_PDU(myValue) == '31800000'O)) {setverdict(pass);} else {setverdict(fail);}
42583 Overall verdict: pass
42589 .*---------------------------------------------------------------------*
42590 :h3.CER + DER encoding of SET OF BOOLEAN
42591 .*---------------------------------------------------------------------*
42594 <TC - CER + DER encoding of SET OF BOOLEAN>
42603 BERPDU ::= SET OF BOOLEAN
42611 import from TempA all;
42612 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42613 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42615 const BERPDU myValue := {true, false }
42622 if ((enc_DER_PDU(myValue) == '31060101000101FF'O)and(enc_CER_PDU(myValue) == '31800101000101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
42626 Overall verdict: pass
42632 .*---------------------------------------------------------------------*
42633 :h3.CER + DER encoding of SET OF OCTET STRING
42634 .*---------------------------------------------------------------------*
42637 <TC - CER + DER encoding of SET OF OCTET STRING >
42646 BERPDU ::= SET OF OCTET STRING
42652 import from TempA all;
42653 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42654 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42656 const BERPDU myValue := {'FFFF'O, 'AB'O };
42660 if ((enc_DER_PDU(myValue) == '31070401AB0402FFFF'O)and(enc_CER_PDU(myValue) == '31800401AB0402FFFF0000'O)) {setverdict(pass);} else {setverdict(fail);}
42664 Overall verdict: pass
42670 .*---------------------------------------------------------------------*
42671 :h3.CER + DER encoding of SET OF SEQUENCE
42672 .*---------------------------------------------------------------------*
42675 <TC - CER + DER encoding of SET OF SEQUENCE >
42684 BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN}
42690 import from TempA all;
42691 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42692 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42694 const BERPDU myValue := {
42709 if ((enc_DER_PDU(myValue) == '3110300602010301010030060201050101FF'O)and(enc_CER_PDU(myValue) == '31803080020103010100000030800201050101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
42713 Overall verdict: pass
42719 .*---------------------------------------------------------------------*
42720 :h3.CER + DER encoding of SET OF SET
42721 .*---------------------------------------------------------------------*
42724 <TC - CER + DER encoding of SET OF SET >
42733 BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN}
42739 import from TempA all;
42740 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42741 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42743 const BERPDU myValue := {
42758 if ((enc_DER_PDU(myValue) == '3110310601010002010331060101FF020105'O)and(enc_CER_PDU(myValue) == '31803180010100020103000031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);}
42762 Overall verdict: pass
42768 .*---------------------------------------------------------------------*
42769 :h3.CER + DER encoding of SET OF CHOICE
42770 .*---------------------------------------------------------------------*
42773 <TC - CER + DER encoding of SET OF CHOICE >
42782 BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN}
42788 import from TempA all;
42789 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42790 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42792 const BERPDU myValue := {
42805 if ((enc_DER_PDU(myValue) == '3106010100020105'O)and(enc_CER_PDU(myValue) == '31800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);}
42809 Overall verdict: pass
42815 .*---------------------------------------------------------------------*
42816 :h3.CER + DER encoding of SET OF SEQUENCE OF
42817 .*---------------------------------------------------------------------*
42820 <TC - CER + DER encoding of SET OF SEQUENCE OF>
42829 BERPDU ::= SET OF SEQUENCE OF INTEGER
42835 import from TempA all;
42836 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42837 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42839 const BERPDU myValue := {
42855 if ((enc_DER_PDU(myValue) == '311630090201010201020201033009020105020106020107'O)and(enc_CER_PDU(myValue) == '318030800201010201020201030000308002010502010602010700000000'O)) {setverdict(pass);} else {setverdict(fail);}
42859 Overall verdict: pass
42865 .*---------------------------------------------------------------------*
42866 :h3.CER + DER encoding of SET OF SET OF
42867 .*---------------------------------------------------------------------*
42870 <TC - CER + DER encoding of SET OF SET OF>
42879 BERPDU ::= SET OF SET OF INTEGER
42885 import from TempA all;
42886 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42887 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42889 const BERPDU myValue := {
42905 if ((enc_DER_PDU(myValue) == '311631090201010201020201033109020105020106020107'O)and(enc_CER_PDU(myValue) == '318031800201010201020201030000318002010502010602010700000000'O)) {setverdict(pass);} else {setverdict(fail);}
42909 Overall verdict: pass
42915 .*---------------------------------------------------------------------*
42916 :h3.CER + DER encoding of TAGGED SET OF BOOLEAN
42917 .*---------------------------------------------------------------------*
42920 <TC - CER + DER encoding of TAGGED SET OF BOOLEAN>
42929 BERPDU ::= [0] SET OF BOOLEAN
42937 import from TempA all;
42938 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42939 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42941 const BERPDU myValue := {true, false }
42948 if ((enc_DER_PDU(myValue) == 'A00831060101000101FF'O)and(enc_CER_PDU(myValue) == 'A08031800101000101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
42952 Overall verdict: pass
42958 .*---------------------------------------------------------------------*
42959 :h3.CER + DER encoding of TAGGED SET OF BOOLEAN, EXPLICIT TAGGING
42960 .*---------------------------------------------------------------------*
42963 <TC - CER + DER encoding of TAGGED SET OF BOOLEAN, EXPLICIT TAGGING>
42977 BERPDU ::= [0] SET OF BOOLEAN
42985 import from TempA all;
42986 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
42987 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
42989 const BERPDU myValue := {true, false }
42996 if ((enc_DER_PDU(myValue) == 'A00831060101000101FF'O)and(enc_CER_PDU(myValue) == 'A08031800101000101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
43000 Overall verdict: pass
43006 .*---------------------------------------------------------------------*
43007 :h3.CER + DER encoding of TAGGED SET OF BOOLEAN, IMPLICIT TAGGING
43008 .*---------------------------------------------------------------------*
43011 <TC - CER + DER encoding of TAGGED SET OF BOOLEAN, IMPLICIT TAGGING>
43025 BERPDU ::= [0] SET OF BOOLEAN
43033 import from TempA all;
43034 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
43035 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
43037 const BERPDU myValue := {true, false }
43044 if ((enc_DER_PDU(myValue) == 'A0060101000101FF'O)and(enc_CER_PDU(myValue) == 'A0800101000101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
43048 Overall verdict: pass
43054 .*---------------------------------------------------------------------*
43055 :h3.CER + DER encoding of SET OF OCTET STRING
43056 .*---------------------------------------------------------------------*
43059 <TC - CER + DER encoding of SET OF OCTET STRING >
43068 BERPDU ::= SET OF OCTET STRING
43074 import from TempA all;
43075 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
43076 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
43078 const BERPDU myValue := {'FFFF'O, ''O };
43082 if ((enc_DER_PDU(myValue) == '310604000402FFFF'O)and(enc_CER_PDU(myValue) == '318004000402FFFF0000'O)) {setverdict(pass);} else {setverdict(fail);}
43086 Overall verdict: pass
43092 .*---------------------------------------------------------------------*
43093 :h3. DECODING DER, SET OF INTEGER (empty)
43094 .*---------------------------------------------------------------------*
43097 <TC - DECODING DER, SET OF INTEGER (empty)>
43106 BERPDU ::= SET OF INTEGER
43112 import from TempA all;
43114 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43116 const BERPDU myValue := { }
43121 if (dec_BER_PDU('3100'O) == myValue)
43123 {setverdict(pass);} else {setverdict(fail);}
43128 Overall verdict: pass
43134 .*---------------------------------------------------------------------*
43135 :h3. DECODING CER, SET OF INTEGER (empty)
43136 .*---------------------------------------------------------------------*
43139 <TC - DECODING CER, SET OF INTEGER (empty)>
43148 BERPDU ::= SET OF INTEGER
43154 import from TempA all;
43156 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43158 const BERPDU myValue := { }
43163 if (dec_BER_PDU('31800000'O) == myValue)
43165 {setverdict(pass);} else {setverdict(fail);}
43170 Overall verdict: pass
43176 .*---------------------------------------------------------------------*
43177 :h3. DECODING DER, SET OF BOOLEAN
43178 .*---------------------------------------------------------------------*
43181 <TC - DECODING DER, SET OF BOOLEAN>
43190 BERPDU ::= SET OF BOOLEAN
43196 import from TempA all;
43198 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43200 const BERPDU myValue := {true, false }
43205 if (dec_BER_PDU('31060101000101FF'O) == myValue)
43207 {setverdict(pass);} else {setverdict(fail);}
43212 Overall verdict: pass
43218 .*---------------------------------------------------------------------*
43219 :h3. DECODING CER, SET OF BOOLEAN
43220 .*---------------------------------------------------------------------*
43223 <TC - DECODING CER, SET OF BOOLEAN>
43232 BERPDU ::= SET OF BOOLEAN
43238 import from TempA all;
43240 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43242 const BERPDU myValue := {true, false }
43247 if (dec_BER_PDU('31800101000101FF0000'O) == myValue)
43249 {setverdict(pass);} else {setverdict(fail);}
43254 Overall verdict: pass
43260 .*---------------------------------------------------------------------*
43261 :h3. DECODING , SET OF BOOLEAN (different order)
43262 .*---------------------------------------------------------------------*
43265 <TC - DECODING , SET OF BOOLEAN (different order)>
43274 BERPDU ::= SET OF BOOLEAN
43280 import from TempA all;
43282 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43284 const BERPDU myValue := {true, false }
43289 if (dec_BER_PDU('31060101FF010100'O) == myValue)
43291 {setverdict(pass);} else {setverdict(fail);}
43296 Overall verdict: pass
43302 .*---------------------------------------------------------------------*
43303 :h3. DECODING , SET OF BOOLEAN (different order2)
43304 .*---------------------------------------------------------------------*
43307 <TC - DECODING , SET OF BOOLEAN (different order2)>
43316 BERPDU ::= SET OF BOOLEAN
43322 import from TempA all;
43324 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43326 const BERPDU myValue := {true, false }
43331 if (dec_BER_PDU('31800101FF0101000000'O) == myValue)
43333 {setverdict(pass);} else {setverdict(fail);}
43338 Overall verdict: pass
43344 .*---------------------------------------------------------------------*
43345 :h3. DECODING DER,SET OF OCTET STRING
43346 .*---------------------------------------------------------------------*
43349 <TC - DECODING DER,SET OF OCTET STRING >
43358 BERPDU ::= SET OF OCTET STRING
43364 import from TempA all;
43366 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43368 const BERPDU myValue := {'FFFF'O, 'AB'O };
43373 if (dec_BER_PDU('31070401AB0402FFFF'O) == myValue)
43375 {setverdict(pass);} else {setverdict(fail);}
43380 Overall verdict: pass
43386 .*---------------------------------------------------------------------*
43387 :h3. DECODING CER,SET OF OCTET STRING
43388 .*---------------------------------------------------------------------*
43391 <TC - DECODING CER,SET OF OCTET STRING >
43400 BERPDU ::= SET OF OCTET STRING
43406 import from TempA all;
43408 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43410 const BERPDU myValue := {'FFFF'O, 'AB'O };
43415 if (dec_BER_PDU('31800401AB0402FFFF0000'O) == myValue)
43417 {setverdict(pass);} else {setverdict(fail);}
43422 Overall verdict: pass
43428 .*---------------------------------------------------------------------*
43429 :h3. DECODING ,SET OF OCTET STRING (different order)
43430 .*---------------------------------------------------------------------*
43433 <TC - DECODING ,SET OF OCTET STRING (different order)>
43442 BERPDU ::= SET OF OCTET STRING
43448 import from TempA all;
43450 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43452 const BERPDU myValue := {'FFFF'O, 'AB'O };
43457 if (dec_BER_PDU('31070402FFFF0401AB'O) == myValue)
43459 {setverdict(pass);} else {setverdict(fail);}
43464 Overall verdict: pass
43470 .*---------------------------------------------------------------------*
43471 :h3. DECODING ,SET OF OCTET STRING (different order)
43472 .*---------------------------------------------------------------------*
43475 <TC - DECODING ,SET OF OCTET STRING (different order)>
43484 BERPDU ::= SET OF OCTET STRING
43490 import from TempA all;
43492 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43494 const BERPDU myValue := {'FFFF'O, 'AB'O };
43499 if (dec_BER_PDU('31800402FFFF0401AB0000'O) == myValue)
43501 {setverdict(pass);} else {setverdict(fail);}
43506 Overall verdict: pass
43512 .*---------------------------------------------------------------------*
43513 :h3. DECODING DER,SET OF SEQUENCE
43514 .*---------------------------------------------------------------------*
43517 <TC - DECODING DER,SET OF SEQUENCE >
43526 BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN}
43532 import from TempA all;
43534 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43536 const BERPDU myValue := {
43552 if (dec_BER_PDU('3110300602010301010030060201050101FF'O) == myValue)
43554 {setverdict(pass);} else {setverdict(fail);}
43559 Overall verdict: pass
43565 .*---------------------------------------------------------------------*
43566 :h3. DECODING CER,SET OF SEQUENCE
43567 .*---------------------------------------------------------------------*
43570 <TC - DECODING CER,SET OF SEQUENCE >
43579 BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN}
43585 import from TempA all;
43587 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43589 const BERPDU myValue := {
43605 if (dec_BER_PDU('31803080020103010100000030800201050101FF00000000'O) == myValue)
43607 {setverdict(pass);} else {setverdict(fail);}
43612 Overall verdict: pass
43618 .*---------------------------------------------------------------------*
43619 :h3. DECODING ,SET OF SEQUENCE (different order)
43620 .*---------------------------------------------------------------------*
43623 <TC - DECODING ,SET OF SEQUENCE (different order)>
43632 BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN}
43638 import from TempA all;
43640 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43642 const BERPDU myValue := {
43658 if (dec_BER_PDU('311030060201050101FF3006020103010100'O) == myValue)
43660 {setverdict(pass);} else {setverdict(fail);}
43665 Overall verdict: pass
43671 .*---------------------------------------------------------------------*
43672 :h3. DECODING ,SET OF SEQUENCE (different order2)
43673 .*---------------------------------------------------------------------*
43676 <TC - DECODING ,SET OF SEQUENCE (different order2)>
43685 BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN}
43691 import from TempA all;
43693 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43695 const BERPDU myValue := {
43711 if (dec_BER_PDU('318030800201050101FF0000308002010301010000000000'O) == myValue)
43713 {setverdict(pass);} else {setverdict(fail);}
43718 Overall verdict: pass
43724 .*---------------------------------------------------------------------*
43725 :h3. DECODING DER,SET OF SET
43726 .*---------------------------------------------------------------------*
43729 <TC - DECODING DER,SET OF SET >
43738 BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN}
43744 import from TempA all;
43746 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43748 const BERPDU myValue := {
43764 if (dec_BER_PDU('3110310601010002010331060101FF020105'O) == myValue)
43766 {setverdict(pass);} else {setverdict(fail);}
43771 Overall verdict: pass
43777 .*---------------------------------------------------------------------*
43778 :h3. DECODING CER,SET OF SET
43779 .*---------------------------------------------------------------------*
43782 <TC - DECODING CER,SET OF SET >
43791 BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN}
43797 import from TempA all;
43799 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43801 const BERPDU myValue := {
43817 if (dec_BER_PDU('31803180010100020103000031800101FF02010500000000'O) == myValue)
43819 {setverdict(pass);} else {setverdict(fail);}
43824 Overall verdict: pass
43830 .*---------------------------------------------------------------------*
43831 :h3. DECODING ,SET OF SET (different order)
43832 .*---------------------------------------------------------------------*
43835 <TC - DECODING ,SET OF SET (different order)>
43844 BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN}
43850 import from TempA all;
43852 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43854 const BERPDU myValue := {
43870 if (dec_BER_PDU('311031060101FF0201053106010100020103'O) == myValue)
43872 {setverdict(pass);} else {setverdict(fail);}
43877 Overall verdict: pass
43883 .*---------------------------------------------------------------------*
43884 :h3. DECODING ,SET OF SET (different order2)
43885 .*---------------------------------------------------------------------*
43888 <TC - DECODING ,SET OF SET (different order2)>
43897 BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN}
43903 import from TempA all;
43905 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43907 const BERPDU myValue := {
43923 if (dec_BER_PDU('318031800101FF0201050000318001010002010300000000'O) == myValue)
43925 {setverdict(pass);} else {setverdict(fail);}
43930 Overall verdict: pass
43936 .*---------------------------------------------------------------------*
43937 :h3. DECODING DER,SET OF CHOICE
43938 .*---------------------------------------------------------------------*
43941 <TC - DECODING DER,SET OF CHOICE >
43950 BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN}
43956 import from TempA all;
43958 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
43960 const BERPDU myValue := {
43974 if (dec_BER_PDU('3106010100020105'O) == myValue)
43976 {setverdict(pass);} else {setverdict(fail);}
43981 Overall verdict: pass
43987 .*---------------------------------------------------------------------*
43988 :h3. DECODING CER,SET OF CHOICE
43989 .*---------------------------------------------------------------------*
43992 <TC - DECODING CER,SET OF CHOICE >
44001 BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN}
44007 import from TempA all;
44009 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44011 const BERPDU myValue := {
44025 if (dec_BER_PDU('31800101000201050000'O) == myValue)
44027 {setverdict(pass);} else {setverdict(fail);}
44032 Overall verdict: pass
44038 .*---------------------------------------------------------------------*
44039 :h3. DECODING ,SET OF CHOICE (different order)
44040 .*---------------------------------------------------------------------*
44043 <TC - DECODING ,SET OF CHOICE (different order)>
44052 BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN}
44058 import from TempA all;
44060 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44062 const BERPDU myValue := {
44076 if (dec_BER_PDU('3106020105010100'O) == myValue)
44078 {setverdict(pass);} else {setverdict(fail);}
44083 Overall verdict: pass
44089 .*---------------------------------------------------------------------*
44090 :h3. DECODING ,SET OF CHOICE (different order2)
44091 .*---------------------------------------------------------------------*
44094 <TC - DECODING ,SET OF CHOICE (different order2)>
44103 BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN}
44109 import from TempA all;
44111 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44113 const BERPDU myValue := {
44127 if (dec_BER_PDU('31800201050101000000'O) == myValue)
44129 {setverdict(pass);} else {setverdict(fail);}
44134 Overall verdict: pass
44140 .*---------------------------------------------------------------------*
44141 :h3. DECODING DER,SET OF SEQUENCE OF
44142 .*---------------------------------------------------------------------*
44145 <TC - DECODING DER,SET OF SEQUENCE OF>
44154 BERPDU ::= SET OF SEQUENCE OF INTEGER
44160 import from TempA all;
44162 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44164 const BERPDU myValue := {
44181 if (dec_BER_PDU('311630090201010201020201033009020105020106020107'O) == myValue)
44183 {setverdict(pass);} else {setverdict(fail);}
44188 Overall verdict: pass
44194 .*---------------------------------------------------------------------*
44195 :h3. DECODING CER,SET OF SEQUENCE OF
44196 .*---------------------------------------------------------------------*
44199 <TC - DECODING CER,SET OF SEQUENCE OF>
44208 BERPDU ::= SET OF SEQUENCE OF INTEGER
44214 import from TempA all;
44216 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44218 const BERPDU myValue := {
44235 if (dec_BER_PDU('318030800201010201020201030000308002010502010602010700000000'O) == myValue)
44237 {setverdict(pass);} else {setverdict(fail);}
44242 Overall verdict: pass
44248 .*---------------------------------------------------------------------*
44249 :h3. DECODING ,SET OF SEQUENCE OF, (different order)
44250 .*---------------------------------------------------------------------*
44253 <TC - DECODING ,SET OF SEQUENCE OF, (different order)>
44262 BERPDU ::= SET OF SEQUENCE OF INTEGER
44268 import from TempA all;
44270 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44272 const BERPDU myValue := {
44289 if (dec_BER_PDU('311630090201050201060201073009020101020102020103'O) == myValue)
44291 {setverdict(pass);} else {setverdict(fail);}
44296 Overall verdict: pass
44302 .*---------------------------------------------------------------------*
44303 :h3. DECODING ,SET OF SEQUENCE OF, (different order2)
44304 .*---------------------------------------------------------------------*
44307 <TC - DECODING ,SET OF SEQUENCE OF, (different order2)>
44316 BERPDU ::= SET OF SEQUENCE OF INTEGER
44322 import from TempA all;
44324 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44326 const BERPDU myValue := {
44343 if (dec_BER_PDU('318030800201050201060201070000308002010102010202010300000000'O) == myValue)
44345 {setverdict(pass);} else {setverdict(fail);}
44350 Overall verdict: pass
44356 .*---------------------------------------------------------------------*
44357 :h3. DECODING DER,SET OF SET OF
44358 .*---------------------------------------------------------------------*
44361 <TC - DECODING DER,SET OF SET OF>
44370 BERPDU ::= SET OF SET OF INTEGER
44376 import from TempA all;
44378 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44380 const BERPDU myValue := {
44397 if (dec_BER_PDU('311631090201010201020201033109020105020106020107'O) == myValue)
44399 {setverdict(pass);} else {setverdict(fail);}
44404 Overall verdict: pass
44410 .*---------------------------------------------------------------------*
44411 :h3. DECODING CER,SET OF SET OF
44412 .*---------------------------------------------------------------------*
44415 <TC - DECODING CER,SET OF SET OF>
44424 BERPDU ::= SET OF SET OF INTEGER
44430 import from TempA all;
44432 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44434 const BERPDU myValue := {
44451 if (dec_BER_PDU('318031800201010201020201030000318002010502010602010700000000'O) == myValue)
44453 {setverdict(pass);} else {setverdict(fail);}
44458 Overall verdict: pass
44464 .*---------------------------------------------------------------------*
44465 :h3. DECODING ,SET OF SET OF (different order)
44466 .*---------------------------------------------------------------------*
44469 <TC - DECODING ,SET OF SET OF (different order)>
44478 BERPDU ::= SET OF SET OF INTEGER
44484 import from TempA all;
44486 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44488 const BERPDU myValue := {
44505 if (dec_BER_PDU('311631090201050201060201073109020101020102020103'O) == myValue)
44507 {setverdict(pass);} else {setverdict(fail);}
44512 Overall verdict: pass
44518 .*---------------------------------------------------------------------*
44519 :h3. DECODING ,SET OF SET OF (different order2)
44520 .*---------------------------------------------------------------------*
44523 <TC - DECODING ,SET OF SET OF (different order2)>
44532 BERPDU ::= SET OF SET OF INTEGER
44538 import from TempA all;
44540 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44542 const BERPDU myValue := {
44559 if (dec_BER_PDU('318031800201050201060201070000318002010102010202010300000000'O) == myValue)
44561 {setverdict(pass);} else {setverdict(fail);}
44566 Overall verdict: pass
44572 .*---------------------------------------------------------------------*
44573 :h3. DECODING DER,TAGGED SET OF BOOLEAN
44574 .*---------------------------------------------------------------------*
44577 <TC - DECODING DER,TAGGED SET OF BOOLEAN>
44586 BERPDU ::= [0] SET OF BOOLEAN
44592 import from TempA all;
44594 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44596 const BERPDU myValue := {true, false }
44601 if (dec_BER_PDU('A00831060101000101FF'O) == myValue)
44603 {setverdict(pass);} else {setverdict(fail);}
44608 Overall verdict: pass
44614 .*---------------------------------------------------------------------*
44615 :h3. DECODING CER,TAGGED SET OF BOOLEAN
44616 .*---------------------------------------------------------------------*
44619 <TC - DECODING CER,TAGGED SET OF BOOLEAN>
44628 BERPDU ::= [0] SET OF BOOLEAN
44634 import from TempA all;
44636 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44638 const BERPDU myValue := {true, false }
44643 if (dec_BER_PDU('A08031800101000101FF00000000'O) == myValue)
44645 {setverdict(pass);} else {setverdict(fail);}
44650 Overall verdict: pass
44656 .*---------------------------------------------------------------------*
44657 :h3. DECODING ,TAGGED SET OF BOOLEAN (different order)
44658 .*---------------------------------------------------------------------*
44661 <TC - DECODING ,TAGGED SET OF BOOLEAN (different order)>
44670 BERPDU ::= [0] SET OF BOOLEAN
44676 import from TempA all;
44678 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44680 const BERPDU myValue := {true, false }
44685 if (dec_BER_PDU('A00831060101FF010100'O) == myValue)
44687 {setverdict(pass);} else {setverdict(fail);}
44692 Overall verdict: pass
44698 .*---------------------------------------------------------------------*
44699 :h3. DECODING ,TAGGED SET OF BOOLEAN (different order2)
44700 .*---------------------------------------------------------------------*
44703 <TC - DECODING ,TAGGED SET OF BOOLEAN (different order2)>
44712 BERPDU ::= [0] SET OF BOOLEAN
44718 import from TempA all;
44720 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44722 const BERPDU myValue := {true, false }
44727 if (dec_BER_PDU('A08031800101FF01010000000000'O) == myValue)
44729 {setverdict(pass);} else {setverdict(fail);}
44734 Overall verdict: pass
44740 .*---------------------------------------------------------------------*
44741 :h3. DECODING DER,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING
44742 .*---------------------------------------------------------------------*
44745 <TC - DECODING DER,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING>
44758 BERPDU ::= [0] SET OF BOOLEAN
44764 import from TempA all;
44766 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44768 const BERPDU myValue := {true, false }
44773 if (dec_BER_PDU('A00831060101000101FF'O) == myValue)
44775 {setverdict(pass);} else {setverdict(fail);}
44780 Overall verdict: pass
44786 .*---------------------------------------------------------------------*
44787 :h3. DECODING CER,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING
44788 .*---------------------------------------------------------------------*
44791 <TC - DECODING CER,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING>
44804 BERPDU ::= [0] SET OF BOOLEAN
44810 import from TempA all;
44812 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44814 const BERPDU myValue := {true, false }
44819 if (dec_BER_PDU('A08031800101000101FF00000000'O) == myValue)
44821 {setverdict(pass);} else {setverdict(fail);}
44826 Overall verdict: pass
44832 .*---------------------------------------------------------------------*
44833 :h3. DECODING ,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING (different order)
44834 .*---------------------------------------------------------------------*
44837 <TC - DECODING ,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING (different order)>
44850 BERPDU ::= [0] SET OF BOOLEAN
44856 import from TempA all;
44858 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44860 const BERPDU myValue := {true, false }
44865 if (dec_BER_PDU('A00831060101FF010100'O) == myValue)
44867 {setverdict(pass);} else {setverdict(fail);}
44872 Overall verdict: pass
44878 .*---------------------------------------------------------------------*
44879 :h3. DECODING ,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING (different order2)
44880 .*---------------------------------------------------------------------*
44883 <TC - DECODING ,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING (different order2)>
44896 BERPDU ::= [0] SET OF BOOLEAN
44902 import from TempA all;
44904 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44906 const BERPDU myValue := {true, false }
44911 if (dec_BER_PDU('A08031800101FF01010000000000'O) == myValue)
44913 {setverdict(pass);} else {setverdict(fail);}
44918 Overall verdict: pass
44924 .*---------------------------------------------------------------------*
44925 :h3. DECODING DER,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING
44926 .*---------------------------------------------------------------------*
44929 <TC - DECODING DER,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING>
44942 BERPDU ::= [0] SET OF BOOLEAN
44948 import from TempA all;
44950 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44952 const BERPDU myValue := {true, false }
44957 if (dec_BER_PDU('A0060101000101FF'O) == myValue)
44959 {setverdict(pass);} else {setverdict(fail);}
44964 Overall verdict: pass
44970 .*---------------------------------------------------------------------*
44971 :h3. DECODING CER,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING
44972 .*---------------------------------------------------------------------*
44975 <TC - DECODING CER,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING>
44988 BERPDU ::= [0] SET OF BOOLEAN
44994 import from TempA all;
44996 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
44998 const BERPDU myValue := {true, false }
45003 if (dec_BER_PDU('A0800101000101FF0000'O) == myValue)
45005 {setverdict(pass);} else {setverdict(fail);}
45010 Overall verdict: pass
45016 .*---------------------------------------------------------------------*
45017 :h3. DECODING ,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING (different order)
45018 .*---------------------------------------------------------------------*
45021 <TC - DECODING ,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING (different order)>
45034 BERPDU ::= [0] SET OF BOOLEAN
45040 import from TempA all;
45042 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
45044 const BERPDU myValue := {true, false }
45049 if (dec_BER_PDU('A0060101FF010100'O) == myValue)
45051 {setverdict(pass);} else {setverdict(fail);}
45056 Overall verdict: pass
45062 .*---------------------------------------------------------------------*
45063 :h3. DECODING ,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING (different order2)
45064 .*---------------------------------------------------------------------*
45067 <TC - DECODING ,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING (different order2)>
45080 BERPDU ::= [0] SET OF BOOLEAN
45086 import from TempA all;
45088 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
45090 const BERPDU myValue := {true, false }
45095 if (dec_BER_PDU('A0800101FF0101000000'O) == myValue)
45097 {setverdict(pass);} else {setverdict(fail);}
45102 Overall verdict: pass
45108 .*---------------------------------------------------------------------*
45109 :h3.CER + DER encoding of CHOICE - NULL
45110 .*---------------------------------------------------------------------*
45113 <TC - CER + DER encoding of CHOICE - NULL>
45127 d ENUMERATED {first ,second ,third},
45132 h OBJECT IDENTIFIER,
45134 j CHOICE {x1 [1] BOOLEAN,
45135 y1 [2] OCTET STRING},
45137 k SEQUENCE{x2 NULL,
45140 l SET { x3 BIT STRING,
45143 m [3] SEQUENCE OF INTEGER,
45144 n [4] SET OF BOOLEAN
45152 import from TempA all;
45153 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45154 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45156 const BERPDU myValue := {a := NULL}
45163 if ((enc_DER_PDU(myValue) == '0500'O)and(enc_CER_PDU(myValue) == '0500'O)) {setverdict(pass);} else {setverdict(fail);}
45167 Overall verdict: pass
45173 .*---------------------------------------------------------------------*
45174 :h3.CER + DER encoding of CHOICE - BOOLEAN
45175 .*---------------------------------------------------------------------*
45178 <TC - CER + DER encoding of CHOICE - BOOLEAN>
45192 d ENUMERATED {first ,second ,third},
45197 h OBJECT IDENTIFIER,
45199 j CHOICE {x1 [1] BOOLEAN,
45200 y1 [2] OCTET STRING},
45202 k SEQUENCE{x2 NULL,
45205 l SET { x3 BIT STRING,
45208 m [3] SEQUENCE OF INTEGER,
45209 n [4] SET OF BOOLEAN
45217 import from TempA all;
45218 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45219 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45221 const BERPDU myValue := {b := true}
45228 if ((enc_DER_PDU(myValue) == '0101FF'O)and(enc_CER_PDU(myValue) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);}
45232 Overall verdict: pass
45238 .*---------------------------------------------------------------------*
45239 :h3.CER + DER encoding of CHOICE - INTEGER
45240 .*---------------------------------------------------------------------*
45243 <TC - CER + DER encoding of CHOICE - INTEGER>
45257 d ENUMERATED {first ,second ,third},
45262 h OBJECT IDENTIFIER,
45264 j CHOICE {x1 [1] BOOLEAN,
45265 y1 [2] OCTET STRING},
45267 k SEQUENCE{x2 NULL,
45270 l SET { x3 BIT STRING,
45273 m [3] SEQUENCE OF INTEGER,
45274 n [4] SET OF BOOLEAN
45282 import from TempA all;
45283 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45284 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45286 const BERPDU myValue := {c := 2}
45293 if ((enc_DER_PDU(myValue) == '020102'O)and(enc_CER_PDU(myValue) == '020102'O)) {setverdict(pass);} else {setverdict(fail);}
45297 Overall verdict: pass
45303 .*---------------------------------------------------------------------*
45304 :h3.CER + DER encoding of CHOICE - ENUMERATED
45305 .*---------------------------------------------------------------------*
45308 <TC - CER + DER encoding of CHOICE - ENUMERATED>
45322 d ENUMERATED {first ,second ,third},
45327 h OBJECT IDENTIFIER,
45329 j CHOICE {x1 [1] BOOLEAN,
45330 y1 [2] OCTET STRING},
45332 k SEQUENCE{x2 NULL,
45335 l SET { x3 BIT STRING,
45338 m [3] SEQUENCE OF INTEGER,
45339 n [4] SET OF BOOLEAN
45347 import from TempA all;
45348 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45349 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45351 const BERPDU myValue := {d := first}
45358 if ((enc_DER_PDU(myValue) == '0A0100'O)and(enc_CER_PDU(myValue) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);}
45362 Overall verdict: pass
45368 .*---------------------------------------------------------------------*
45369 :h3.CER + DER encoding of CHOICE - REAL
45370 .*---------------------------------------------------------------------*
45373 <TC - CER + DER encoding of CHOICE - REAL>
45387 d ENUMERATED {first ,second ,third},
45392 h OBJECT IDENTIFIER,
45394 j CHOICE {x1 [1] BOOLEAN,
45395 y1 [2] OCTET STRING},
45397 k SEQUENCE{x2 NULL,
45400 l SET { x3 BIT STRING,
45403 m [3] SEQUENCE OF INTEGER,
45404 n [4] SET OF BOOLEAN
45412 import from TempA all;
45413 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45414 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45416 const BERPDU myValue := {e := 1.0}
45423 if ((enc_DER_PDU(myValue) == '090603312E452B30'O)and(enc_CER_PDU(myValue) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);}
45427 Overall verdict: pass
45433 .*---------------------------------------------------------------------*
45434 :h3.CER + DER encoding of CHOICE - BIT STRING
45435 .*---------------------------------------------------------------------*
45438 <TC - CER + DER encoding of CHOICE - BIT STRING>
45452 d ENUMERATED {first ,second ,third},
45457 h OBJECT IDENTIFIER,
45459 j CHOICE {x1 [1] BOOLEAN,
45460 y1 [2] OCTET STRING},
45462 k SEQUENCE{x2 NULL,
45465 l SET { x3 BIT STRING,
45468 m [3] SEQUENCE OF INTEGER,
45469 n [4] SET OF BOOLEAN
45477 import from TempA all;
45478 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45479 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45481 const BERPDU myValue := {f := '1'B}
45488 if ((enc_DER_PDU(myValue) == '03020780'O)and(enc_CER_PDU(myValue) == '03020780'O)) {setverdict(pass);} else {setverdict(fail);}
45492 Overall verdict: pass
45498 .*---------------------------------------------------------------------*
45499 :h3.CER + DER encoding of CHOICE - OCTET STRING
45500 .*---------------------------------------------------------------------*
45503 <TC - CER + DER encoding of CHOICE - OCTET STRING>
45517 d ENUMERATED {first ,second ,third},
45522 h OBJECT IDENTIFIER,
45524 j CHOICE {x1 [1] BOOLEAN,
45525 y1 [2] OCTET STRING},
45527 k SEQUENCE{x2 NULL,
45530 l SET { x3 BIT STRING,
45533 m [3] SEQUENCE OF INTEGER,
45534 n [4] SET OF BOOLEAN
45542 import from TempA all;
45543 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45544 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45546 const BERPDU myValue := {g := 'FFFF'O}
45553 if ((enc_DER_PDU(myValue) == '0402FFFF'O)and(enc_CER_PDU(myValue) == '0402FFFF'O)) {setverdict(pass);} else {setverdict(fail);}
45557 Overall verdict: pass
45563 .*---------------------------------------------------------------------*
45564 :h3.CER + DER encoding of CHOICE - OBJECT IDENTIFIER
45565 .*---------------------------------------------------------------------*
45568 <TC - CER + DER encoding of CHOICE - OBJECT IDENTIFIER>
45582 d ENUMERATED {first ,second ,third},
45587 h OBJECT IDENTIFIER,
45589 j CHOICE {x1 [1] BOOLEAN,
45590 y1 [2] OCTET STRING},
45592 k SEQUENCE{x2 NULL,
45595 l SET { x3 BIT STRING,
45598 m [3] SEQUENCE OF INTEGER,
45599 n [4] SET OF BOOLEAN
45604 myValue BERPDU ::= h : {itu-t(0) recommendation(0) a(2) b(3)}
45612 import from TempA all;
45613 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45614 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45622 if ((enc_DER_PDU(myValue) == '0603000203'O)and(enc_CER_PDU(myValue) == '0603000203'O)) {setverdict(pass);} else {setverdict(fail);}
45626 Overall verdict: pass
45632 .*---------------------------------------------------------------------*
45633 :h3.CER + DER encoding of CHOICE - IA5String
45634 .*---------------------------------------------------------------------*
45637 <TC - CER + DER encoding of CHOICE - IA5String>
45651 d ENUMERATED {first ,second ,third},
45656 h OBJECT IDENTIFIER,
45658 j CHOICE {x1 [1] BOOLEAN,
45659 y1 [2] OCTET STRING},
45661 k SEQUENCE{x2 NULL,
45664 l SET { x3 BIT STRING,
45667 m [3] SEQUENCE OF INTEGER,
45668 n [4] SET OF BOOLEAN
45676 import from TempA all;
45677 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45678 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45680 const BERPDU myValue := {i := "ABC"}
45687 if ((enc_DER_PDU(myValue) == '1603414243'O)and(enc_CER_PDU(myValue) == '1603414243'O)) {setverdict(pass);} else {setverdict(fail);}
45691 Overall verdict: pass
45697 .*---------------------------------------------------------------------*
45698 :h3.CER + DER encoding of CHOICE - CHOICE
45699 .*---------------------------------------------------------------------*
45702 <TC - CER + DER encoding of CHOICE - CHOICE>
45716 d ENUMERATED {first ,second ,third},
45721 h OBJECT IDENTIFIER,
45723 j CHOICE {x1 [1] BOOLEAN,
45724 y1 [2] OCTET STRING},
45726 k SEQUENCE{x2 NULL,
45729 l SET { x3 BIT STRING,
45732 m [3] SEQUENCE OF INTEGER,
45733 n [4] SET OF BOOLEAN
45741 import from TempA all;
45742 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45743 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45745 const BERPDU myValue := {j := {x1 := true } }
45752 if ((enc_DER_PDU(myValue) == 'A1030101FF'O)and(enc_CER_PDU(myValue) == 'A1800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
45756 Overall verdict: pass
45762 .*---------------------------------------------------------------------*
45763 :h3.CER + DER encoding of CHOICE - SEQUENCE
45764 .*---------------------------------------------------------------------*
45767 <TC - CER + DER encoding of CHOICE - SEQUENCE>
45781 d ENUMERATED {first ,second ,third},
45786 h OBJECT IDENTIFIER,
45788 j CHOICE {x1 [1] BOOLEAN,
45789 y1 [2] OCTET STRING},
45791 k SEQUENCE{x2 NULL,
45794 l SET { x3 BIT STRING,
45797 m [3] SEQUENCE OF INTEGER,
45798 n [4] SET OF BOOLEAN
45806 import from TempA all;
45807 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45808 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45810 const BERPDU myValue := {k := {x2 := NULL,
45819 if ((enc_DER_PDU(myValue) == '300505000101FF'O)and(enc_CER_PDU(myValue) == '308005000101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
45823 Overall verdict: pass
45829 .*---------------------------------------------------------------------*
45830 :h3.CER + DER encoding of CHOICE - SET
45831 .*---------------------------------------------------------------------*
45834 <TC - CER + DER encoding of CHOICE - SET>
45848 d ENUMERATED {first ,second ,third},
45853 h OBJECT IDENTIFIER,
45855 j CHOICE {x1 [1] BOOLEAN,
45856 y1 [2] OCTET STRING},
45858 k SEQUENCE{x2 NULL,
45861 l SET { x3 BIT STRING,
45864 m [3] SEQUENCE OF INTEGER,
45865 n [4] SET OF BOOLEAN
45873 import from TempA all;
45874 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45875 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45877 const BERPDU myValue := {l := {y3 := 1.0 ,
45886 if ((enc_DER_PDU(myValue) == '310C03020780090603312E452B30'O)and(enc_CER_PDU(myValue) == '318003020780090603312E452B300000'O)) {setverdict(pass);} else {setverdict(fail);}
45890 Overall verdict: pass
45896 .*---------------------------------------------------------------------*
45897 :h3.CER + DER encoding of CHOICE - SEQUENCE OF
45898 .*---------------------------------------------------------------------*
45901 <TC - CER + DER encoding of CHOICE - SEQUENCE OF>
45915 d ENUMERATED {first ,second ,third},
45920 h OBJECT IDENTIFIER,
45922 j CHOICE {x1 [1] BOOLEAN,
45923 y1 [2] OCTET STRING},
45925 k SEQUENCE{x2 NULL,
45928 l SET { x3 BIT STRING,
45931 m [3] SEQUENCE OF INTEGER,
45932 n [4] SET OF BOOLEAN
45940 import from TempA all;
45941 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
45942 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
45944 const BERPDU myValue := {m :=
45952 if ((enc_DER_PDU(myValue) == 'A3083006020101020102'O)and(enc_CER_PDU(myValue) == 'A380308002010102010200000000'O)) {setverdict(pass);} else {setverdict(fail);}
45956 Overall verdict: pass
45962 .*---------------------------------------------------------------------*
45963 :h3.CER + DER encoding of CHOICE - SET OF
45964 .*---------------------------------------------------------------------*
45967 <TC - CER + DER encoding of CHOICE - SET OF>
45981 d ENUMERATED {first ,second ,third},
45986 h OBJECT IDENTIFIER,
45988 j CHOICE {x1 [1] BOOLEAN,
45989 y1 [2] OCTET STRING},
45991 k SEQUENCE{x2 NULL,
45994 l SET { x3 BIT STRING,
45997 m [3] SEQUENCE OF INTEGER,
45998 n [4] SET OF BOOLEAN
46006 import from TempA all;
46007 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46008 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46010 const BERPDU myValue := {n :=
46018 if ((enc_DER_PDU(myValue) == 'A40831060101FF0101FF'O)and(enc_CER_PDU(myValue) == 'A48031800101FF0101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
46022 Overall verdict: pass
46028 .*---------------------------------------------------------------------*
46029 :h3.CER + DER encoding of CHOICE - Default IMPLICIT TAGS, CHOICE untagged
46030 .*---------------------------------------------------------------------*
46033 <TC - CER + DER encoding of CHOICE - Default IMPLICIT TAGS, CHOICE untagged>
46058 import from TempA all;
46059 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46060 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46062 const BERPDU myValue := {b := true }
46069 if ((enc_DER_PDU(myValue) == '0101FF'O)and(enc_CER_PDU(myValue) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);}
46074 Overall verdict: pass
46080 .*---------------------------------------------------------------------*
46081 :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, CHOICE untagged
46082 .*---------------------------------------------------------------------*
46085 <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, CHOICE untagged>
46110 import from TempA all;
46111 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46112 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46114 const BERPDU myValue := {b := true }
46121 if ((enc_DER_PDU(myValue) == '0101FF'O)and(enc_CER_PDU(myValue) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);}
46126 Overall verdict: pass
46132 .*---------------------------------------------------------------------*
46133 :h3.CER + DER encoding of CHOICE - No Default TAGS, CHOICE untagged
46134 .*---------------------------------------------------------------------*
46137 <TC - CER + DER encoding of CHOICE - No Default TAGS, CHOICE untagged>
46161 import from TempA all;
46162 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46163 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46165 const BERPDU myValue := {b := true }
46172 if ((enc_DER_PDU(myValue) == '0101FF'O)and(enc_CER_PDU(myValue) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);}
46177 Overall verdict: pass
46183 .*---------------------------------------------------------------------*
46184 :h3.CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, CHOICE untagged
46185 .*---------------------------------------------------------------------*
46188 <TC - CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, CHOICE untagged>
46213 import from TempA all;
46214 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46215 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46217 const BERPDU myValue := {b := true }
46224 if ((enc_DER_PDU(myValue) == '8001FF'O)and(enc_CER_PDU(myValue) == '8001FF'O)) {setverdict(pass);} else {setverdict(fail);}
46229 Overall verdict: pass
46235 .*---------------------------------------------------------------------*
46236 :h3.CER + DER encoding of CHOICE - Default IMPLICIT TAGS, number-tagged CHOICE
46237 .*---------------------------------------------------------------------*
46240 <TC - CER + DER encoding of CHOICE - Default IMPLICIT TAGS, number-tagged CHOICE>
46265 import from TempA all;
46266 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46267 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46269 const BERPDU myValue := {b := true }
46276 if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);}
46281 Overall verdict: pass
46287 .*---------------------------------------------------------------------*
46288 :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE
46289 .*---------------------------------------------------------------------*
46292 <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE>
46317 import from TempA all;
46318 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46319 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46321 const BERPDU myValue := {b := true }
46328 if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
46333 Overall verdict: pass
46339 .*---------------------------------------------------------------------*
46340 :h3.CER + DER encoding of CHOICE - No Default TAGS, number-tagged CHOICE
46341 .*---------------------------------------------------------------------*
46344 <TC - CER + DER encoding of CHOICE - No Default TAGS, number-tagged CHOICE>
46364 import from TempA all;
46365 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46366 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46368 const BERPDU myValue := {b := true }
46375 if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
46380 Overall verdict: pass
46386 .*---------------------------------------------------------------------*
46387 :h3.CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE
46388 .*---------------------------------------------------------------------*
46391 <TC - CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE>
46416 import from TempA all;
46417 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46418 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46420 const BERPDU myValue := {b := true }
46427 if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);}
46432 Overall verdict: pass
46438 .*---------------------------------------------------------------------*
46439 :h3.CER + DER encoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE
46440 .*---------------------------------------------------------------------*
46443 <TC - CER + DER encoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE>
46459 b [3] IMPLICIT BOOLEAN,
46468 import from TempA all;
46469 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46470 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46472 const BERPDU myValue := {b := true }
46479 if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);}
46484 Overall verdict: pass
46490 .*---------------------------------------------------------------------*
46491 :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
46492 .*---------------------------------------------------------------------*
46495 <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
46511 b [3] IMPLICIT BOOLEAN,
46520 import from TempA all;
46521 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46522 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46524 const BERPDU myValue := {b := true }
46531 if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);}
46536 Overall verdict: pass
46542 .*---------------------------------------------------------------------*
46543 :h3.CER + DER encoding of CHOICE - No Default TAGS, fully-tagged CHOICE
46544 .*---------------------------------------------------------------------*
46547 <TC - CER + DER encoding of CHOICE - No Default TAGS, fully-tagged CHOICE>
46562 b [3] IMPLICIT BOOLEAN,
46571 import from TempA all;
46572 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46573 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46575 const BERPDU myValue := {b := true }
46582 if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);}
46587 Overall verdict: pass
46593 .*---------------------------------------------------------------------*
46594 :h3.CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE
46595 .*---------------------------------------------------------------------*
46598 <TC - CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE>
46614 b [3] IMPLICIT BOOLEAN,
46623 import from TempA all;
46624 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46625 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46627 const BERPDU myValue := {b := true }
46634 if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);}
46639 Overall verdict: pass
46645 .*---------------------------------------------------------------------*
46646 :h3.CER + DER encoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE
46647 .*---------------------------------------------------------------------*
46650 <TC - CER + DER encoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE>
46666 b [3] EXPLICIT BOOLEAN,
46675 import from TempA all;
46676 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46677 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46679 const BERPDU myValue := {b := true }
46686 if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
46691 Overall verdict: pass
46697 .*---------------------------------------------------------------------*
46698 :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
46699 .*---------------------------------------------------------------------*
46702 <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
46718 b [3] EXPLICIT BOOLEAN,
46727 import from TempA all;
46728 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46729 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46731 const BERPDU myValue := {b := true }
46738 if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
46743 Overall verdict: pass
46749 .*---------------------------------------------------------------------*
46750 :h3.CER + DER encoding of CHOICE - No Default TAGS, fully-tagged CHOICE
46751 .*---------------------------------------------------------------------*
46754 <TC - CER + DER encoding of CHOICE - No Default TAGS, fully-tagged CHOICE>
46769 b [3] EXPLICIT BOOLEAN,
46778 import from TempA all;
46779 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46780 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46782 const BERPDU myValue := {b := true }
46789 if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
46794 Overall verdict: pass
46800 .*---------------------------------------------------------------------*
46801 :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
46802 .*---------------------------------------------------------------------*
46805 <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
46821 b [3] EXPLICIT BOOLEAN,
46830 import from TempA all;
46831 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46832 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46834 const BERPDU myValue := {b := true }
46841 if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
46846 Overall verdict: pass
46852 .*---------------------------------------------------------------------*
46853 :h3.CER + DER encoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,
46854 .*---------------------------------------------------------------------*
46857 <TC - CER + DER encoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,>
46871 BERPDU ::= [0] CHOICE
46882 import from TempA all;
46883 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46884 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46886 const BERPDU myValue := {b := true }
46893 if ((enc_DER_PDU(myValue) == 'A0038301FF'O)and(enc_CER_PDU(myValue) == 'A0808301FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
46898 Overall verdict: pass
46904 .*---------------------------------------------------------------------*
46905 :h3.CER + DER encoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,
46906 .*---------------------------------------------------------------------*
46909 <TC - CER + DER encoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,>
46923 BERPDU ::= [0] CHOICE
46934 import from TempA all;
46935 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46936 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46938 const BERPDU myValue := {b := true }
46945 if ((enc_DER_PDU(myValue) == 'A005A3030101FF'O)and(enc_CER_PDU(myValue) == 'A080A3800101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
46950 Overall verdict: pass
46956 .*---------------------------------------------------------------------*
46957 :h3.CER + DER encoding of CHOICE, NO DEFAULT, TAGGED CHOICE,
46958 .*---------------------------------------------------------------------*
46961 <TC - CER + DER encoding of CHOICE, NO DEFAULT, TAGGED CHOICE,>
46975 BERPDU ::= [0] CHOICE
46986 import from TempA all;
46987 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
46988 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
46990 const BERPDU myValue := {b := true }
46997 if ((enc_DER_PDU(myValue) == 'A005A3030101FF'O)and(enc_CER_PDU(myValue) == 'A080A3800101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);}
47002 Overall verdict: pass
47008 .*---------------------------------------------------------------------*
47009 :h3.CER + DER encoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,
47010 .*---------------------------------------------------------------------*
47013 <TC - CER + DER encoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,>
47027 BERPDU ::= [0] CHOICE
47038 import from TempA all;
47039 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
47040 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
47042 const BERPDU myValue := {b := true }
47049 if ((enc_DER_PDU(myValue) == 'A0038301FF'O)and(enc_CER_PDU(myValue) == 'A0808301FF0000'O)) {setverdict(pass);} else {setverdict(fail);}
47054 Overall verdict: pass
47060 .*---------------------------------------------------------------------*
47061 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - NULL
47062 .*---------------------------------------------------------------------*
47065 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - NULL>
47078 d ENUMERATED {first ,second ,third},
47083 h OBJECT IDENTIFIER,
47085 j CHOICE {x1 [1] BOOLEAN,
47086 y1 [2] OCTET STRING},
47088 k SEQUENCE{x2 NULL,
47091 l SET { x3 BIT STRING,
47094 m [3] SEQUENCE OF INTEGER,
47095 n [4] SET OF BOOLEAN
47101 import from TempA all;
47103 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47104 const BERPDU myValue := {a := NULL}
47108 if (dec_BER_PDU('0500'O) == myValue)
47111 {setverdict(pass);} else {setverdict(fail);}
47116 Overall verdict: pass
47122 .*---------------------------------------------------------------------*
47123 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - BOOLEAN
47124 .*---------------------------------------------------------------------*
47127 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - BOOLEAN>
47140 d ENUMERATED {first ,second ,third},
47145 h OBJECT IDENTIFIER,
47147 j CHOICE {x1 [1] BOOLEAN,
47148 y1 [2] OCTET STRING},
47150 k SEQUENCE{x2 NULL,
47153 l SET { x3 BIT STRING,
47156 m [3] SEQUENCE OF INTEGER,
47157 n [4] SET OF BOOLEAN
47163 import from TempA all;
47165 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47166 const BERPDU myValue := {b := true}
47170 if (dec_BER_PDU('0101FF'O) == myValue)
47173 {setverdict(pass);} else {setverdict(fail);}
47178 Overall verdict: pass
47184 .*---------------------------------------------------------------------*
47185 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - INTEGER
47186 .*---------------------------------------------------------------------*
47189 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - INTEGER>
47202 d ENUMERATED {first ,second ,third},
47207 h OBJECT IDENTIFIER,
47209 j CHOICE {x1 [1] BOOLEAN,
47210 y1 [2] OCTET STRING},
47212 k SEQUENCE{x2 NULL,
47215 l SET { x3 BIT STRING,
47218 m [3] SEQUENCE OF INTEGER,
47219 n [4] SET OF BOOLEAN
47225 import from TempA all;
47227 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47228 const BERPDU myValue := {c := 2}
47232 if (dec_BER_PDU('020102'O) == myValue)
47235 {setverdict(pass);} else {setverdict(fail);}
47240 Overall verdict: pass
47246 .*---------------------------------------------------------------------*
47247 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - ENUMERATED
47248 .*---------------------------------------------------------------------*
47251 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - ENUMERATED>
47264 d ENUMERATED {first ,second ,third},
47269 h OBJECT IDENTIFIER,
47271 j CHOICE {x1 [1] BOOLEAN,
47272 y1 [2] OCTET STRING},
47274 k SEQUENCE{x2 NULL,
47277 l SET { x3 BIT STRING,
47280 m [3] SEQUENCE OF INTEGER,
47281 n [4] SET OF BOOLEAN
47287 import from TempA all;
47289 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47290 const BERPDU myValue := {d := first}
47294 if (dec_BER_PDU('0A0100'O) == myValue)
47297 {setverdict(pass);} else {setverdict(fail);}
47302 Overall verdict: pass
47308 .*---------------------------------------------------------------------*
47309 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - BIT STRING
47310 .*---------------------------------------------------------------------*
47313 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - BIT STRING>
47326 d ENUMERATED {first ,second ,third},
47331 h OBJECT IDENTIFIER,
47333 j CHOICE {x1 [1] BOOLEAN,
47334 y1 [2] OCTET STRING},
47336 k SEQUENCE{x2 NULL,
47339 l SET { x3 BIT STRING,
47342 m [3] SEQUENCE OF INTEGER,
47343 n [4] SET OF BOOLEAN
47349 import from TempA all;
47351 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47352 const BERPDU myValue := {f := '1'B}
47356 if (dec_BER_PDU('03020780'O) == myValue)
47359 {setverdict(pass);} else {setverdict(fail);}
47364 Overall verdict: pass
47370 .*---------------------------------------------------------------------*
47371 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - OCTET STRING
47372 .*---------------------------------------------------------------------*
47375 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - OCTET STRING>
47388 d ENUMERATED {first ,second ,third},
47393 h OBJECT IDENTIFIER,
47395 j CHOICE {x1 [1] BOOLEAN,
47396 y1 [2] OCTET STRING},
47398 k SEQUENCE{x2 NULL,
47401 l SET { x3 BIT STRING,
47404 m [3] SEQUENCE OF INTEGER,
47405 n [4] SET OF BOOLEAN
47411 import from TempA all;
47413 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47414 const BERPDU myValue := {g := 'FFFF'O}
47418 if (dec_BER_PDU('0402FFFF'O) == myValue)
47421 {setverdict(pass);} else {setverdict(fail);}
47426 Overall verdict: pass
47432 .*---------------------------------------------------------------------*
47433 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - OBJECT IDENTIFIER
47434 .*---------------------------------------------------------------------*
47437 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - OBJECT IDENTIFIER>
47450 d ENUMERATED {first ,second ,third},
47455 h OBJECT IDENTIFIER,
47457 j CHOICE {x1 [1] BOOLEAN,
47458 y1 [2] OCTET STRING},
47460 k SEQUENCE{x2 NULL,
47463 l SET { x3 BIT STRING,
47466 m [3] SEQUENCE OF INTEGER,
47467 n [4] SET OF BOOLEAN
47470 myValue BERPDU ::= h : {itu-t(0) recommendation(0) a(2) b(3)}
47477 import from TempA all;
47479 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47483 if (dec_BER_PDU('0603000203'O) == myValue)
47486 {setverdict(pass);} else {setverdict(fail);}
47491 Overall verdict: pass
47497 .*---------------------------------------------------------------------*
47498 :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - IA5String
47499 .*---------------------------------------------------------------------*
47502 <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - IA5String>
47515 d ENUMERATED {first ,second ,third},
47520 h OBJECT IDENTIFIER,
47522 j CHOICE {x1 [1] BOOLEAN,
47523 y1 [2] OCTET STRING},
47525 k SEQUENCE{x2 NULL,
47528 l SET { x3 BIT STRING,
47531 m [3] SEQUENCE OF INTEGER,
47532 n [4] SET OF BOOLEAN
47541 import from TempA all;
47543 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47545 const BERPDU myValue := {i := "ABC"}
47550 if (dec_BER_PDU('1603414243'O) == myValue)
47553 {setverdict(pass);} else {setverdict(fail);}
47558 Overall verdict: pass
47564 .*---------------------------------------------------------------------*
47565 :h3. DECODING OBJECT IDENTIFIER ,DER, CHOICE - CHOICE
47566 .*---------------------------------------------------------------------*
47569 <TC - DECODING OBJECT IDENTIFIER ,DER, CHOICE - CHOICE>
47582 d ENUMERATED {first ,second ,third},
47587 h OBJECT IDENTIFIER,
47589 j CHOICE {x1 [1] BOOLEAN,
47590 y1 [2] OCTET STRING},
47592 k SEQUENCE{x2 NULL,
47595 l SET { x3 BIT STRING,
47598 m [3] SEQUENCE OF INTEGER,
47599 n [4] SET OF BOOLEAN
47608 import from TempA all;
47610 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47612 const BERPDU myValue := {j := {x1 := true } }
47617 if (dec_BER_PDU('A1030101FF'O) == myValue)
47620 {setverdict(pass);} else {setverdict(fail);}
47625 Overall verdict: pass
47631 .*---------------------------------------------------------------------*
47632 :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - CHOICE
47633 .*---------------------------------------------------------------------*
47636 <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - CHOICE>
47649 d ENUMERATED {first ,second ,third},
47654 h OBJECT IDENTIFIER,
47656 j CHOICE {x1 [1] BOOLEAN,
47657 y1 [2] OCTET STRING},
47659 k SEQUENCE{x2 NULL,
47662 l SET { x3 BIT STRING,
47665 m [3] SEQUENCE OF INTEGER,
47666 n [4] SET OF BOOLEAN
47675 import from TempA all;
47677 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47679 const BERPDU myValue := {j := {x1 := true } }
47684 if (dec_BER_PDU('A1800101FF0000'O) == myValue)
47687 {setverdict(pass);} else {setverdict(fail);}
47692 Overall verdict: pass
47698 .*---------------------------------------------------------------------*
47699 :h3. DECODING OBJECT IDENTIFIER , DER, CHOICE - SEQUENCE
47700 .*---------------------------------------------------------------------*
47703 <TC - DECODING OBJECT IDENTIFIER , DER, CHOICE - SEQUENCE>
47716 d ENUMERATED {first ,second ,third},
47721 h OBJECT IDENTIFIER,
47723 j CHOICE {x1 [1] BOOLEAN,
47724 y1 [2] OCTET STRING},
47726 k SEQUENCE{x2 NULL,
47729 l SET { x3 BIT STRING,
47732 m [3] SEQUENCE OF INTEGER,
47733 n [4] SET OF BOOLEAN
47742 import from TempA all;
47744 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47746 const BERPDU myValue := {k := {x2 := NULL,
47754 if (dec_BER_PDU('300505000101FF'O) == myValue)
47757 {setverdict(pass);} else {setverdict(fail);}
47762 Overall verdict: pass
47768 .*---------------------------------------------------------------------*
47769 :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - SEQUENCE
47770 .*---------------------------------------------------------------------*
47773 <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - SEQUENCE>
47786 d ENUMERATED {first ,second ,third},
47791 h OBJECT IDENTIFIER,
47793 j CHOICE {x1 [1] BOOLEAN,
47794 y1 [2] OCTET STRING},
47796 k SEQUENCE{x2 NULL,
47799 l SET { x3 BIT STRING,
47802 m [3] SEQUENCE OF INTEGER,
47803 n [4] SET OF BOOLEAN
47812 import from TempA all;
47814 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47816 const BERPDU myValue := {k := {x2 := NULL,
47824 if (dec_BER_PDU('308005000101FF0000'O) == myValue)
47827 {setverdict(pass);} else {setverdict(fail);}
47832 Overall verdict: pass
47838 .*---------------------------------------------------------------------*
47839 :h3. DECODING OBJECT IDENTIFIER , DER, CHOICE - SET
47840 .*---------------------------------------------------------------------*
47843 <TC - DECODING OBJECT IDENTIFIER , DER, CHOICE - SET>
47856 d ENUMERATED {first ,second ,third},
47861 h OBJECT IDENTIFIER,
47863 j CHOICE {x1 [1] BOOLEAN,
47864 y1 [2] OCTET STRING},
47866 k SEQUENCE{x2 NULL,
47869 l SET { x3 BIT STRING,
47872 m [3] SEQUENCE OF INTEGER,
47873 n [4] SET OF BOOLEAN
47882 import from TempA all;
47884 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47886 const BERPDU myValue := {l := {y3 := 'FFFF'O ,
47895 if (dec_BER_PDU('3108030207800402FFFF'O) == myValue)
47898 {setverdict(pass);} else {setverdict(fail);}
47903 Overall verdict: pass
47909 .*---------------------------------------------------------------------*
47910 :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - SET
47911 .*---------------------------------------------------------------------*
47914 <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - SET>
47927 d ENUMERATED {first ,second ,third},
47932 h OBJECT IDENTIFIER,
47934 j CHOICE {x1 [1] BOOLEAN,
47935 y1 [2] OCTET STRING},
47937 k SEQUENCE{x2 NULL,
47940 l SET { x3 BIT STRING,
47943 m [3] SEQUENCE OF INTEGER,
47944 n [4] SET OF BOOLEAN
47953 import from TempA all;
47955 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
47957 const BERPDU myValue := {l := {y3 := 'FFFF'O ,
47966 if (dec_BER_PDU('3180030207800402FFFF0000'O) == myValue)
47969 {setverdict(pass);} else {setverdict(fail);}
47974 Overall verdict: pass
47980 .*---------------------------------------------------------------------*
47981 :h3. DECODING OBJECT IDENTIFIER , DER, CHOICE - SEQUENCE OF
47982 .*---------------------------------------------------------------------*
47985 <TC - DECODING OBJECT IDENTIFIER , DER, CHOICE - SEQUENCE OF>
47998 d ENUMERATED {first ,second ,third},
48003 h OBJECT IDENTIFIER,
48005 j CHOICE {x1 [1] BOOLEAN,
48006 y1 [2] OCTET STRING},
48008 k SEQUENCE{x2 NULL,
48011 l SET { x3 BIT STRING,
48014 m [3] SEQUENCE OF INTEGER,
48015 n [4] SET OF BOOLEAN
48024 import from TempA all;
48026 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48028 const BERPDU myValue := {m :=
48035 if (dec_BER_PDU('A3083006020101020102'O) == myValue)
48038 {setverdict(pass);} else {setverdict(fail);}
48043 Overall verdict: pass
48049 .*---------------------------------------------------------------------*
48050 :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - SEQUENCE OF
48051 .*---------------------------------------------------------------------*
48054 <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - SEQUENCE OF>
48067 d ENUMERATED {first ,second ,third},
48072 h OBJECT IDENTIFIER,
48074 j CHOICE {x1 [1] BOOLEAN,
48075 y1 [2] OCTET STRING},
48077 k SEQUENCE{x2 NULL,
48080 l SET { x3 BIT STRING,
48083 m [3] SEQUENCE OF INTEGER,
48084 n [4] SET OF BOOLEAN
48093 import from TempA all;
48095 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48097 const BERPDU myValue := {m :=
48104 if (dec_BER_PDU('A380308002010102010200000000'O) == myValue)
48107 {setverdict(pass);} else {setverdict(fail);}
48112 Overall verdict: pass
48118 .*---------------------------------------------------------------------*
48119 :h3. DECODING OBJECT IDENTIFIER , DER, CHOICE - SET OF
48120 .*---------------------------------------------------------------------*
48123 <TC - DECODING OBJECT IDENTIFIER , DER, CHOICE - SET OF>
48136 d ENUMERATED {first ,second ,third},
48141 h OBJECT IDENTIFIER,
48143 j CHOICE {x1 [1] BOOLEAN,
48144 y1 [2] OCTET STRING},
48146 k SEQUENCE{x2 NULL,
48149 l SET { x3 BIT STRING,
48152 m [3] SEQUENCE OF INTEGER,
48153 n [4] SET OF BOOLEAN
48162 import from TempA all;
48164 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48166 const BERPDU myValue := {n :=
48173 if (dec_BER_PDU('A40831060101FF0101FF'O) == myValue)
48176 {setverdict(pass);} else {setverdict(fail);}
48181 Overall verdict: pass
48187 .*---------------------------------------------------------------------*
48188 :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - SET OF
48189 .*---------------------------------------------------------------------*
48192 <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - SET OF>
48205 d ENUMERATED {first ,second ,third},
48210 h OBJECT IDENTIFIER,
48212 j CHOICE {x1 [1] BOOLEAN,
48213 y1 [2] OCTET STRING},
48215 k SEQUENCE{x2 NULL,
48218 l SET { x3 BIT STRING,
48221 m [3] SEQUENCE OF INTEGER,
48222 n [4] SET OF BOOLEAN
48231 import from TempA all;
48233 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48235 const BERPDU myValue := {n :=
48242 if (dec_BER_PDU('A48031800101FF0101FF00000000'O) == myValue)
48245 {setverdict(pass);} else {setverdict(fail);}
48250 Overall verdict: pass
48256 .*---------------------------------------------------------------------*
48257 :h3.CER + DER decoding of CHOICE - Default IMPLICIT TAGS, CHOICE untagged
48258 .*---------------------------------------------------------------------*
48261 <TC - CER + DER decoding of CHOICE - Default IMPLICIT TAGS, CHOICE untagged>
48286 import from TempA all;
48288 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48290 const BERPDU myValue := {b := true }
48296 if (dec_BER_PDU('0101FF'O) == myValue)
48299 {setverdict(pass);} else {setverdict(fail);}
48304 Overall verdict: pass
48310 .*---------------------------------------------------------------------*
48311 :h3.CER + DER decoding of CHOICE - Default EXPLICIT TAGS, CHOICE untagged
48312 .*---------------------------------------------------------------------*
48315 <TC - CER + DER decoding of CHOICE - Default EXPLICIT TAGS, CHOICE untagged>
48341 import from TempA all;
48343 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48345 const BERPDU myValue := {b := true }
48351 if (dec_BER_PDU('0101FF'O) == myValue)
48354 {setverdict(pass);} else {setverdict(fail);}
48359 Overall verdict: pass
48365 .*---------------------------------------------------------------------*
48366 :h3.CER + DER decoding of CHOICE - No Default TAGS, CHOICE untagged
48367 .*---------------------------------------------------------------------*
48370 <TC - CER + DER decoding of CHOICE - No Default TAGS, CHOICE untagged>
48396 import from TempA all;
48398 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48400 const BERPDU myValue := {b := true }
48406 if (dec_BER_PDU('0101FF'O) == myValue)
48409 {setverdict(pass);} else {setverdict(fail);}
48414 Overall verdict: pass
48420 .*---------------------------------------------------------------------*
48421 :h3.CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, CHOICE untagged
48422 .*---------------------------------------------------------------------*
48425 <TC - CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, CHOICE untagged>
48451 import from TempA all;
48453 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48455 const BERPDU myValue := {b := true }
48461 if (dec_BER_PDU('8001FF'O) == myValue)
48464 {setverdict(pass);} else {setverdict(fail);}
48469 Overall verdict: pass
48475 .*---------------------------------------------------------------------*
48476 :h3.CER + DER decoding of CHOICE - Default IMPLICIT TAGS, number-tagged CHOICE
48477 .*---------------------------------------------------------------------*
48480 <TC - CER + DER decoding of CHOICE - Default IMPLICIT TAGS, number-tagged CHOICE>
48509 import from TempA all;
48511 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48513 const BERPDU myValue := {b := true }
48519 if (dec_BER_PDU('8301FF'O) == myValue)
48522 {setverdict(pass);} else {setverdict(fail);}
48527 Overall verdict: pass
48533 .*---------------------------------------------------------------------*
48534 :h3. DER decoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE
48535 .*---------------------------------------------------------------------*
48538 <TC - DER decoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE>
48567 import from TempA all;
48569 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48571 const BERPDU myValue := {b := true }
48577 if (dec_BER_PDU('A3030101FF'O) == myValue)
48580 {setverdict(pass);} else {setverdict(fail);}
48585 Overall verdict: pass
48591 .*---------------------------------------------------------------------*
48592 :h3. CER decoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE
48593 .*---------------------------------------------------------------------*
48596 <TC - CER decoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE>
48623 import from TempA all;
48625 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48627 const BERPDU myValue := {b := true }
48633 if (dec_BER_PDU('A3800101FF0000'O) == myValue)
48636 {setverdict(pass);} else {setverdict(fail);}
48641 Overall verdict: pass
48647 .*---------------------------------------------------------------------*
48648 :h3. DER decoding of CHOICE - No Default TAGS, number-tagged CHOICE
48649 .*---------------------------------------------------------------------*
48652 <TC - DER decoding of CHOICE - No Default TAGS, number-tagged CHOICE>
48678 import from TempA all;
48680 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48682 const BERPDU myValue := {b := true }
48688 if (dec_BER_PDU('A3030101FF'O) == myValue)
48691 {setverdict(pass);} else {setverdict(fail);}
48696 Overall verdict: pass
48702 .*---------------------------------------------------------------------*
48703 :h3. CER decoding of CHOICE - No Default TAGS, number-tagged CHOICE
48704 .*---------------------------------------------------------------------*
48707 <TC - CER decoding of CHOICE - No Default TAGS, number-tagged CHOICE>
48734 import from TempA all;
48736 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48738 const BERPDU myValue := {b := true }
48744 if (dec_BER_PDU('A3800101FF0000'O) == myValue)
48747 {setverdict(pass);} else {setverdict(fail);}
48752 Overall verdict: pass
48758 .*---------------------------------------------------------------------*
48759 :h3. CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE
48760 .*---------------------------------------------------------------------*
48763 <TC - CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE>
48791 import from TempA all;
48793 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48795 const BERPDU myValue := {b := true }
48801 if (dec_BER_PDU('8301FF'O) == myValue)
48804 {setverdict(pass);} else {setverdict(fail);}
48809 Overall verdict: pass
48815 .*---------------------------------------------------------------------*
48816 :h3. CER + DER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE
48817 .*---------------------------------------------------------------------*
48820 <TC - CER + DER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE>
48836 b [3] IMPLICIT BOOLEAN,
48847 import from TempA all;
48849 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48851 const BERPDU myValue := {b := true }
48857 if (dec_BER_PDU('8301FF'O) == myValue)
48860 {setverdict(pass);} else {setverdict(fail);}
48865 Overall verdict: pass
48871 .*---------------------------------------------------------------------*
48872 :h3. CER + DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
48873 .*---------------------------------------------------------------------*
48876 <TC - CER + DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
48892 b [3] IMPLICIT BOOLEAN,
48903 import from TempA all;
48905 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48907 const BERPDU myValue := {b := true }
48913 if (dec_BER_PDU('8301FF'O) == myValue)
48916 {setverdict(pass);} else {setverdict(fail);}
48921 Overall verdict: pass
48927 .*---------------------------------------------------------------------*
48928 :h3. CER + DER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE
48929 .*---------------------------------------------------------------------*
48932 <TC - CER + DER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE>
48947 b [3] IMPLICIT BOOLEAN,
48958 import from TempA all;
48960 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
48962 const BERPDU myValue := {b := true }
48968 if (dec_BER_PDU('8301FF'O) == myValue)
48971 {setverdict(pass);} else {setverdict(fail);}
48976 Overall verdict: pass
48982 .*---------------------------------------------------------------------*
48983 :h3. CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE
48984 .*---------------------------------------------------------------------*
48987 <TC - CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE>
49005 b [3] IMPLICIT BOOLEAN,
49017 import from TempA all;
49019 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49021 const BERPDU myValue := {b := true }
49027 if (dec_BER_PDU('8301FF'O) == myValue)
49030 {setverdict(pass);} else {setverdict(fail);}
49035 Overall verdict: pass
49041 .*---------------------------------------------------------------------*
49042 :h3. DER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE
49043 .*---------------------------------------------------------------------*
49046 <TC - DER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE>
49065 b [3] EXPLICIT BOOLEAN,
49076 import from TempA all;
49078 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49080 const BERPDU myValue := {b := true }
49086 if (dec_BER_PDU('A3030101FF'O) == myValue)
49089 {setverdict(pass);} else {setverdict(fail);}
49094 Overall verdict: pass
49100 .*---------------------------------------------------------------------*
49101 :h3. CER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE
49102 .*---------------------------------------------------------------------*
49105 <TC - CER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE>
49124 b [3] EXPLICIT BOOLEAN,
49135 import from TempA all;
49137 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49139 const BERPDU myValue := {b := true }
49145 if (dec_BER_PDU('A3800101FF0000'O) == myValue)
49148 {setverdict(pass);} else {setverdict(fail);}
49153 Overall verdict: pass
49159 .*---------------------------------------------------------------------*
49160 :h3. DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
49161 .*---------------------------------------------------------------------*
49164 <TC - DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
49183 b [3] EXPLICIT BOOLEAN,
49194 import from TempA all;
49196 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49198 const BERPDU myValue := {b := true }
49204 if (dec_BER_PDU('A3030101FF'O) == myValue)
49207 {setverdict(pass);} else {setverdict(fail);}
49212 Overall verdict: pass
49218 .*---------------------------------------------------------------------*
49219 :h3. CER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
49220 .*---------------------------------------------------------------------*
49223 <TC - CER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
49242 b [3] EXPLICIT BOOLEAN,
49253 import from TempA all;
49255 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49257 const BERPDU myValue := {b := true }
49263 if (dec_BER_PDU('A3800101FF0000'O) == myValue)
49266 {setverdict(pass);} else {setverdict(fail);}
49271 Overall verdict: pass
49277 .*---------------------------------------------------------------------*
49278 :h3. DER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE
49279 .*---------------------------------------------------------------------*
49282 <TC - DER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE>
49300 b [3] EXPLICIT BOOLEAN,
49311 import from TempA all;
49313 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49315 const BERPDU myValue := {b := true }
49321 if (dec_BER_PDU('A3030101FF'O) == myValue)
49324 {setverdict(pass);} else {setverdict(fail);}
49329 Overall verdict: pass
49335 .*---------------------------------------------------------------------*
49336 :h3. CER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE
49337 .*---------------------------------------------------------------------*
49340 <TC - CER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE>
49358 b [3] EXPLICIT BOOLEAN,
49369 import from TempA all;
49371 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49373 const BERPDU myValue := {b := true }
49379 if (dec_BER_PDU('A3800101FF0000'O) == myValue)
49382 {setverdict(pass);} else {setverdict(fail);}
49387 Overall verdict: pass
49393 .*---------------------------------------------------------------------*
49394 :h3. DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
49395 .*---------------------------------------------------------------------*
49398 <TC - DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
49417 b [3] EXPLICIT BOOLEAN,
49428 import from TempA all;
49430 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49432 const BERPDU myValue := {b := true }
49438 if (dec_BER_PDU('A3030101FF'O) == myValue)
49441 {setverdict(pass);} else {setverdict(fail);}
49446 Overall verdict: pass
49452 .*---------------------------------------------------------------------*
49453 :h3. CER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE
49454 .*---------------------------------------------------------------------*
49457 <TC - CER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE>
49476 b [3] EXPLICIT BOOLEAN,
49487 import from TempA all;
49489 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49491 const BERPDU myValue := {b := true }
49497 if (dec_BER_PDU('A3800101FF0000'O) == myValue)
49500 {setverdict(pass);} else {setverdict(fail);}
49505 Overall verdict: pass
49511 .*---------------------------------------------------------------------*
49512 :h3. DER decoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,
49513 .*---------------------------------------------------------------------*
49516 <TC - DER decoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,>
49534 BERPDU ::= [0] CHOICE
49547 import from TempA all;
49549 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49551 const BERPDU myValue := {b := true }
49557 if (dec_BER_PDU('A0038301FF'O) == myValue)
49560 {setverdict(pass);} else {setverdict(fail);}
49565 Overall verdict: pass
49571 .*---------------------------------------------------------------------*
49572 :h3. CER decoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,
49573 .*---------------------------------------------------------------------*
49576 <TC - CER decoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,>
49594 BERPDU ::= [0] CHOICE
49607 import from TempA all;
49609 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49611 const BERPDU myValue := {b := true }
49617 if (dec_BER_PDU('A0808301FF0000'O) == myValue)
49620 {setverdict(pass);} else {setverdict(fail);}
49625 Overall verdict: pass
49631 .*---------------------------------------------------------------------*
49632 :h3. DER decoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,
49633 .*---------------------------------------------------------------------*
49636 <TC - DER decoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,>
49654 BERPDU ::= [0] CHOICE
49667 import from TempA all;
49669 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49671 const BERPDU myValue := {b := true }
49677 if (dec_BER_PDU('A005A3030101FF'O) == myValue)
49680 {setverdict(pass);} else {setverdict(fail);}
49685 Overall verdict: pass
49691 .*---------------------------------------------------------------------*
49692 :h3. CER decoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,
49693 .*---------------------------------------------------------------------*
49696 <TC - CER decoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,>
49714 BERPDU ::= [0] CHOICE
49727 import from TempA all;
49729 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49731 const BERPDU myValue := {b := true }
49737 if (dec_BER_PDU('A080A3800101FF00000000'O) == myValue)
49740 {setverdict(pass);} else {setverdict(fail);}
49745 Overall verdict: pass
49751 .*---------------------------------------------------------------------*
49752 :h3. DER decoding of CHOICE, NO DEFAULT, TAGGED CHOICE,
49753 .*---------------------------------------------------------------------*
49756 <TC - DER decoding of CHOICE, NO DEFAULT, TAGGED CHOICE,>
49773 BERPDU ::= [0] CHOICE
49786 import from TempA all;
49788 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49790 const BERPDU myValue := {b := true }
49796 if (dec_BER_PDU('A005A3030101FF'O) == myValue)
49799 {setverdict(pass);} else {setverdict(fail);}
49804 Overall verdict: pass
49810 .*---------------------------------------------------------------------*
49811 :h3. CER decoding of CHOICE, NO DEFAULT, TAGGED CHOICE,
49812 .*---------------------------------------------------------------------*
49815 <TC - CER decoding of CHOICE, NO DEFAULT, TAGGED CHOICE,>
49832 BERPDU ::= [0] CHOICE
49845 import from TempA all;
49847 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49849 const BERPDU myValue := {b := true }
49855 if (dec_BER_PDU('A080A3800101FF00000000'O) == myValue)
49858 {setverdict(pass);} else {setverdict(fail);}
49863 Overall verdict: pass
49869 .*---------------------------------------------------------------------*
49870 :h3. DER decoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,
49871 .*---------------------------------------------------------------------*
49874 <TC - DER decoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,>
49892 BERPDU ::= [0] CHOICE
49905 import from TempA all;
49907 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49909 const BERPDU myValue := {b := true }
49915 if (dec_BER_PDU('A0038301FF'O) == myValue)
49918 {setverdict(pass);} else {setverdict(fail);}
49923 Overall verdict: pass
49929 .*---------------------------------------------------------------------*
49930 :h3. CER decoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,
49931 .*---------------------------------------------------------------------*
49934 <TC - CER decoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,>
49952 BERPDU ::= [0] CHOICE
49965 import from TempA all;
49967 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
49969 const BERPDU myValue := {b := true }
49975 if (dec_BER_PDU('A0808301FF0000'O) == myValue)
49978 {setverdict(pass);} else {setverdict(fail);}
49983 Overall verdict: pass
49989 .*---------------------------------------------------------------------*
49990 :h3.CER + DER encoding of OBJECT IDENTIFIER , itu-t(0) recommendation(0) (primitive)
49991 .*---------------------------------------------------------------------*
49994 <TC - CER + DER encoding of OBJECT IDENTIFIER , itu-t(0) recommendation(0) (primitive)>
50002 BERPDU ::= OBJECT IDENTIFIER
50003 b BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)}
50009 import from TempA all;
50010 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50011 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50017 if ((enc_DER_PDU(b) == '0603000203'O)and(enc_CER_PDU(b) == '0603000203'O)) {setverdict(pass);} else {setverdict(fail);}
50021 Overall verdict: pass
50027 .*---------------------------------------------------------------------*
50028 :h3.CER + DER encoding of OBJECT IDENTIFIER , itu-t recommendation (primitive)
50029 .*---------------------------------------------------------------------*
50032 <TC - CER + DER encoding of OBJECT IDENTIFIER , itu-t recommendation (primitive)>
50040 BERPDU ::= OBJECT IDENTIFIER
50041 b BERPDU ::= {itu-t recommendation a(2) b(3)}
50047 import from TempA all;
50048 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50049 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50055 if ((enc_DER_PDU(b) == '0603000203'O)and(enc_CER_PDU(b) == '0603000203'O)) {setverdict(pass);} else {setverdict(fail);}
50059 Overall verdict: pass
50065 .*---------------------------------------------------------------------*
50066 :h3.CER + DER encoding of OBJECT IDENTIFIER , 0 0 (primitive)
50067 .*---------------------------------------------------------------------*
50070 <TC - CER + DER encoding of OBJECT IDENTIFIER , 0 0 (primitive)>
50078 BERPDU ::= OBJECT IDENTIFIER
50079 b BERPDU ::= {0 0 a(2) b(3)}
50085 import from TempA all;
50086 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50087 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50093 if ((enc_DER_PDU(b) == '0603000203'O)and(enc_CER_PDU(b) == '0603000203'O)) {setverdict(pass);} else {setverdict(fail);}
50097 Overall verdict: pass
50103 .*---------------------------------------------------------------------*
50104 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) question(1),(primitive)
50105 .*---------------------------------------------------------------------*
50108 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) question(1),(primitive)>
50116 BERPDU ::= OBJECT IDENTIFIER
50117 b BERPDU ::= {itu-t(0) question(1) a(2) b(3)}
50123 import from TempA all;
50124 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50125 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50131 if ((enc_DER_PDU(b) == '0603010203'O)and(enc_CER_PDU(b) == '0603010203'O)) {setverdict(pass);} else {setverdict(fail);}
50135 Overall verdict: pass
50141 .*---------------------------------------------------------------------*
50142 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t question,(primitive)
50143 .*---------------------------------------------------------------------*
50146 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t question,(primitive)>
50154 BERPDU ::= OBJECT IDENTIFIER
50155 b BERPDU ::= {itu-t question a(2) b(3)}
50161 import from TempA all;
50162 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50163 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50169 if ((enc_DER_PDU(b) == '0603010203'O)and(enc_CER_PDU(b) == '0603010203'O)) {setverdict(pass);} else {setverdict(fail);}
50173 Overall verdict: pass
50179 .*---------------------------------------------------------------------*
50180 :h3.CER + DER encoding of OBJECT IDENTIFIER ,0 1,(primitive)
50181 .*---------------------------------------------------------------------*
50184 <TC - CER + DER encoding of OBJECT IDENTIFIER ,0 1,(primitive)>
50192 BERPDU ::= OBJECT IDENTIFIER
50193 b BERPDU ::= {0 1 a(2) b(3)}
50199 import from TempA all;
50200 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50201 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50207 if ((enc_DER_PDU(b) == '0603010203'O)and(enc_CER_PDU(b) == '0603010203'O)) {setverdict(pass);} else {setverdict(fail);}
50211 Overall verdict: pass
50217 .*---------------------------------------------------------------------*
50218 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) administration(2),(primitive)
50219 .*---------------------------------------------------------------------*
50222 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) administration(2),(primitive)>
50230 BERPDU ::= OBJECT IDENTIFIER
50231 b BERPDU ::= {itu-t(0) administration(2) a(2) b(3)}
50237 import from TempA all;
50238 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50239 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50245 if ((enc_DER_PDU(b) == '0603020203'O)and(enc_CER_PDU(b) == '0603020203'O)) {setverdict(pass);} else {setverdict(fail);}
50249 Overall verdict: pass
50255 .*---------------------------------------------------------------------*
50256 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t administration,(primitive)
50257 .*---------------------------------------------------------------------*
50260 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t administration,(primitive)>
50268 BERPDU ::= OBJECT IDENTIFIER
50269 b BERPDU ::= {itu-t administration a(2) b(3)}
50275 import from TempA all;
50276 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50277 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50283 if ((enc_DER_PDU(b) == '0603020203'O)and(enc_CER_PDU(b) == '0603020203'O)) {setverdict(pass);} else {setverdict(fail);}
50287 Overall verdict: pass
50293 .*---------------------------------------------------------------------*
50294 :h3.CER + DER encoding of OBJECT IDENTIFIER ,0 2,(primitive)
50295 .*---------------------------------------------------------------------*
50298 <TC - CER + DER encoding of OBJECT IDENTIFIER ,0 2,(primitive)>
50306 BERPDU ::= OBJECT IDENTIFIER
50307 b BERPDU ::= {0 2 a(2) b(3)}
50313 import from TempA all;
50314 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50315 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50321 if ((enc_DER_PDU(b) == '0603020203'O)and(enc_CER_PDU(b) == '0603020203'O)) {setverdict(pass);} else {setverdict(fail);}
50325 Overall verdict: pass
50331 .*---------------------------------------------------------------------*
50332 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) network-operator(3),(primitive)
50333 .*---------------------------------------------------------------------*
50336 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) network-operator(3),(primitive)>
50344 BERPDU ::= OBJECT IDENTIFIER
50345 b BERPDU ::= {itu-t(0) network-operator(3) a(2) b(3)}
50351 import from TempA all;
50352 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50353 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50359 if ((enc_DER_PDU(b) == '0603030203'O)and(enc_CER_PDU(b) == '0603030203'O)) {setverdict(pass);} else {setverdict(fail);}
50363 Overall verdict: pass
50369 .*---------------------------------------------------------------------*
50370 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t network-operator,(primitive)
50371 .*---------------------------------------------------------------------*
50374 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t network-operator,(primitive)>
50382 BERPDU ::= OBJECT IDENTIFIER
50383 b BERPDU ::= {itu-t network-operator a(2) b(3)}
50389 import from TempA all;
50390 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50391 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50397 if ((enc_DER_PDU(b) == '0603030203'O)and(enc_CER_PDU(b) == '0603030203'O)) {setverdict(pass);} else {setverdict(fail);}
50401 Overall verdict: pass
50407 .*---------------------------------------------------------------------*
50408 :h3.CER + DER encoding of OBJECT IDENTIFIER ,0 3,(primitive)
50409 .*---------------------------------------------------------------------*
50412 <TC - CER + DER encoding of OBJECT IDENTIFIER ,0 3,(primitive)>
50420 BERPDU ::= OBJECT IDENTIFIER
50421 b BERPDU ::= {0 3 a(2) b(3)}
50427 import from TempA all;
50428 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50429 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50435 if ((enc_DER_PDU(b) == '0603030203'O)and(enc_CER_PDU(b) == '0603030203'O)) {setverdict(pass);} else {setverdict(fail);}
50439 Overall verdict: pass
50445 .*---------------------------------------------------------------------*
50446 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) identified-organization(4),(primitive)
50447 .*---------------------------------------------------------------------*
50450 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) identified-organization(4),(primitive)>
50458 BERPDU ::= OBJECT IDENTIFIER
50459 b BERPDU ::= {itu-t(0) identified-organization(4) a(2) b(3)}
50465 import from TempA all;
50466 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50467 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50473 if ((enc_DER_PDU(b) == '0603040203'O)and(enc_CER_PDU(b) == '0603040203'O)) {setverdict(pass);} else {setverdict(fail);}
50477 Overall verdict: pass
50483 .*---------------------------------------------------------------------*
50484 :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t identified-organization,(primitive)
50485 .*---------------------------------------------------------------------*
50488 <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t identified-organization,(primitive)>
50496 BERPDU ::= OBJECT IDENTIFIER
50497 b BERPDU ::= {itu-t identified-organization a(2) b(3)}
50503 import from TempA all;
50504 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50505 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50511 if ((enc_DER_PDU(b) == '0603040203'O)and(enc_CER_PDU(b) == '0603040203'O)) {setverdict(pass);} else {setverdict(fail);}
50515 Overall verdict: pass
50521 .*---------------------------------------------------------------------*
50522 :h3.CER + DER encoding of OBJECT IDENTIFIER ,0 4,(primitive)
50523 .*---------------------------------------------------------------------*
50526 <TC - CER + DER encoding of OBJECT IDENTIFIER ,0 4,(primitive)>
50534 BERPDU ::= OBJECT IDENTIFIER
50535 b BERPDU ::= {0 4 a(2) b(3)}
50541 import from TempA all;
50542 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50543 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50549 if ((enc_DER_PDU(b) == '0603040203'O)and(enc_CER_PDU(b) == '0603040203'O)) {setverdict(pass);} else {setverdict(fail);}
50553 Overall verdict: pass
50559 .*---------------------------------------------------------------------*
50560 :h3.CER + DER encoding of OBJECT IDENTIFIER , iso(1) standard(0) (primitive)
50561 .*---------------------------------------------------------------------*
50564 <TC - CER + DER encoding of OBJECT IDENTIFIER , iso(1) standard(0) (primitive)>
50572 BERPDU ::= OBJECT IDENTIFIER
50573 b BERPDU ::= {iso(1) standard(0) a(2) b(3)}
50579 import from TempA all;
50580 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50581 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50587 if ((enc_DER_PDU(b) == '0603280203'O)and(enc_CER_PDU(b) == '0603280203'O)) {setverdict(pass);} else {setverdict(fail);}
50591 Overall verdict: pass
50597 .*---------------------------------------------------------------------*
50598 :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso standard (primitive)
50599 .*---------------------------------------------------------------------*
50602 <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso standard (primitive)>
50610 BERPDU ::= OBJECT IDENTIFIER
50611 b BERPDU ::= {iso standard a(2) b(3)}
50617 import from TempA all;
50618 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50619 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50625 if ((enc_DER_PDU(b) == '0603280203'O)and(enc_CER_PDU(b) == '0603280203'O)) {setverdict(pass);} else {setverdict(fail);}
50629 Overall verdict: pass
50635 .*---------------------------------------------------------------------*
50636 :h3.CER + DER encoding of OBJECT IDENTIFIER , 1 0 (primitive)
50637 .*---------------------------------------------------------------------*
50640 <TC - CER + DER encoding of OBJECT IDENTIFIER , 1 0 (primitive)>
50648 BERPDU ::= OBJECT IDENTIFIER
50649 b BERPDU ::= {1 0 a(2) b(3)}
50655 import from TempA all;
50656 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50657 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50663 if ((enc_DER_PDU(b) == '0603280203'O)and(enc_CER_PDU(b) == '0603280203'O)) {setverdict(pass);} else {setverdict(fail);}
50667 Overall verdict: pass
50673 .*---------------------------------------------------------------------*
50674 :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso(1) member-body(2)(primitive)
50675 .*---------------------------------------------------------------------*
50678 <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso(1) member-body(2)(primitive)>
50686 BERPDU ::= OBJECT IDENTIFIER
50687 b BERPDU ::= {iso(1) member-body(2) a(2) b(3)}
50693 import from TempA all;
50694 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50695 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50701 if ((enc_DER_PDU(b) == '06032A0203'O)and(enc_CER_PDU(b) == '06032A0203'O)) {setverdict(pass);} else {setverdict(fail);}
50705 Overall verdict: pass
50711 .*---------------------------------------------------------------------*
50712 :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso member-body(primitive)
50713 .*---------------------------------------------------------------------*
50716 <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso member-body(primitive)>
50724 BERPDU ::= OBJECT IDENTIFIER
50725 b BERPDU ::= {iso member-body a(2) b(3)}
50731 import from TempA all;
50732 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50733 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50739 if ((enc_DER_PDU(b) == '06032A0203'O)and(enc_CER_PDU(b) == '06032A0203'O)) {setverdict(pass);} else {setverdict(fail);}
50743 Overall verdict: pass
50749 .*---------------------------------------------------------------------*
50750 :h3.CER + DER encoding of OBJECT IDENTIFIER , 1 2 (primitive)
50751 .*---------------------------------------------------------------------*
50754 <TC - CER + DER encoding of OBJECT IDENTIFIER , 1 2 (primitive)>
50762 BERPDU ::= OBJECT IDENTIFIER
50763 b BERPDU ::= {1 2 a(2) b(3)}
50769 import from TempA all;
50770 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50771 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50777 if ((enc_DER_PDU(b) == '06032A0203'O)and(enc_CER_PDU(b) == '06032A0203'O)) {setverdict(pass);} else {setverdict(fail);}
50781 Overall verdict: pass
50787 .*---------------------------------------------------------------------*
50788 :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso(1) identified-organization(3) (primitive)
50789 .*---------------------------------------------------------------------*
50792 <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso(1) identified-organization(3) (primitive)>
50800 BERPDU ::= OBJECT IDENTIFIER
50801 b BERPDU ::= {iso(1) identified-organization(3) a(2) b(3)}
50807 import from TempA all;
50808 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50809 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50815 if ((enc_DER_PDU(b) == '06032B0203'O)and(enc_CER_PDU(b) == '06032B0203'O)) {setverdict(pass);} else {setverdict(fail);}
50819 Overall verdict: pass
50825 .*---------------------------------------------------------------------*
50826 :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso identified-organization(primitive)
50827 .*---------------------------------------------------------------------*
50830 <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso identified-organization(primitive)>
50838 BERPDU ::= OBJECT IDENTIFIER
50839 b BERPDU ::= {iso identified-organization a(2) b(3)}
50845 import from TempA all;
50846 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50847 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50853 if ((enc_DER_PDU(b) == '06032B0203'O)and(enc_CER_PDU(b) == '06032B0203'O)) {setverdict(pass);} else {setverdict(fail);}
50857 Overall verdict: pass
50863 .*---------------------------------------------------------------------*
50864 :h3.CER + DER encoding of OBJECT IDENTIFIER , 1 3 (primitive)
50865 .*---------------------------------------------------------------------*
50868 <TC - CER + DER encoding of OBJECT IDENTIFIER , 1 3 (primitive)>
50876 BERPDU ::= OBJECT IDENTIFIER
50877 b BERPDU ::= {1 3 a(2) b(3)}
50883 import from TempA all;
50884 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50885 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50891 if ((enc_DER_PDU(b) == '06032B0203'O)and(enc_CER_PDU(b) == '06032B0203'O)) {setverdict(pass);} else {setverdict(fail);}
50895 Overall verdict: pass
50901 .*---------------------------------------------------------------------*
50902 :h3.CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t(2) something(0)(primitive)
50903 .*---------------------------------------------------------------------*
50906 <TC - CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t(2) something(0)(primitive)>
50914 BERPDU ::= OBJECT IDENTIFIER
50915 b BERPDU ::= {joint-iso-itu-t(2) something(0) a(2) b(3)}
50921 import from TempA all;
50922 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50923 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50929 if ((enc_DER_PDU(b) == '0603500203'O)and(enc_CER_PDU(b) == '0603500203'O)) {setverdict(pass);} else {setverdict(fail);}
50933 Overall verdict: pass
50939 .*---------------------------------------------------------------------*
50940 :h3.CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t something(0) (primitive)
50941 .*---------------------------------------------------------------------*
50944 <TC - CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t something(0) (primitive)>
50952 BERPDU ::= OBJECT IDENTIFIER
50953 b BERPDU ::= {joint-iso-itu-t something(0) a(2) b(3)}
50959 import from TempA all;
50960 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50961 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
50967 if ((enc_DER_PDU(b) == '0603500203'O)and(enc_CER_PDU(b) == '0603500203'O)) {setverdict(pass);} else {setverdict(fail);}
50971 Overall verdict: pass
50977 .*---------------------------------------------------------------------*
50978 :h3.CER + DER encoding of OBJECT IDENTIFIER , 2 0 (primitive)
50979 .*---------------------------------------------------------------------*
50982 <TC - CER + DER encoding of OBJECT IDENTIFIER , 2 0 (primitive)>
50990 BERPDU ::= OBJECT IDENTIFIER
50991 b BERPDU ::= {2 0 a(2) b(3)}
50997 import from TempA all;
50998 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
50999 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
51005 if ((enc_DER_PDU(b) == '0603500203'O)and(enc_CER_PDU(b) == '0603500203'O)) {setverdict(pass);} else {setverdict(fail);}
51009 Overall verdict: pass
51015 .*---------------------------------------------------------------------*
51016 :h3.CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t(2) something(100) (primitive)
51017 .*---------------------------------------------------------------------*
51020 <TC - CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t(2) something(100) (primitive)>
51028 BERPDU ::= OBJECT IDENTIFIER
51029 b BERPDU ::= {joint-iso-itu-t(2) something(100) a(2) b(3)}
51035 import from TempA all;
51036 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
51037 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
51043 if ((enc_DER_PDU(b) == '060481340203'O)and(enc_CER_PDU(b) == '060481340203'O)) {setverdict(pass);} else {setverdict(fail);}
51047 Overall verdict: pass
51053 .*---------------------------------------------------------------------*
51054 :h3.CER + DER encoding of OBJECT IDENTIFIER ,joint-iso-itu-t 100 (primitive)
51055 .*---------------------------------------------------------------------*
51058 <TC - CER + DER encoding of OBJECT IDENTIFIER ,joint-iso-itu-t 100 (primitive)>
51066 BERPDU ::= OBJECT IDENTIFIER
51067 b BERPDU ::= {joint-iso-itu-t 100 a(2) b(3)}
51073 import from TempA all;
51074 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
51075 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
51081 if ((enc_DER_PDU(b) == '060481340203'O)and(enc_CER_PDU(b) == '060481340203'O)) {setverdict(pass);} else {setverdict(fail);}
51085 Overall verdict: pass
51091 .*---------------------------------------------------------------------*
51092 :h3.CER + DER encoding of OBJECT IDENTIFIER , 2 100 (primitive)
51093 .*---------------------------------------------------------------------*
51096 <TC - CER + DER encoding of OBJECT IDENTIFIER , 2 100 (primitive)>
51104 BERPDU ::= OBJECT IDENTIFIER
51105 b BERPDU ::= {2 100 a(2) b(3)}
51111 import from TempA all;
51112 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
51113 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
51119 if ((enc_DER_PDU(b) == '060481340203'O)and(enc_CER_PDU(b) == '060481340203'O)) {setverdict(pass);} else {setverdict(fail);}
51123 Overall verdict: pass
51129 .*---------------------------------------------------------------------*
51130 :h3.CER + DER encoding of OBJECT IDENTIFIER , multiple octets needed for values (primitive)
51131 .*---------------------------------------------------------------------*
51134 <TC - CER + DER encoding of OBJECT IDENTIFIER , multiple octets needed for values (primitive)>
51142 BERPDU ::= OBJECT IDENTIFIER
51143 b BERPDU ::= {joint-iso-itu-t(2) something(0) a(2) b(3) 2000 4000 }
51149 import from TempA all;
51150 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
51151 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
51157 if ((enc_DER_PDU(b) == '06075002038F509F20'O)and(enc_CER_PDU(b) == '06075002038F509F20'O)) {setverdict(pass);} else {setverdict(fail);}
51161 Overall verdict: pass
51167 .*---------------------------------------------------------------------*
51168 :h3.CER + DER encoding of OBJECT IDENTIFIER , [0] IMPLICIT, primitive
51169 .*---------------------------------------------------------------------*
51172 <TC - CER + DER encoding of OBJECT IDENTIFIER , [0] IMPLICIT, primitive>
51180 BERPDU ::= [0] IMPLICIT OBJECT IDENTIFIER
51181 b BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)}
51187 import from TempA all;
51188 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
51189 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
51195 if ((enc_DER_PDU(b) == '8003000203'O)and(enc_CER_PDU(b) == '8003000203'O)) {setverdict(pass);} else {setverdict(fail);}
51199 Overall verdict: pass
51205 .*---------------------------------------------------------------------*
51206 :h3.CER + DER encoding of OBJECT IDENTIFIER , [0] EXPLICIT constructed
51207 .*---------------------------------------------------------------------*
51210 <TC - CER + DER encoding of OBJECT IDENTIFIER , [0] EXPLICIT constructed>
51218 BERPDU ::= [0] EXPLICIT OBJECT IDENTIFIER
51219 b BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)}
51225 import from TempA all;
51226 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
51227 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
51233 if ((enc_DER_PDU(b) == 'A0050603000203'O)and(enc_CER_PDU(b) == 'A08006030002030000'O)) {setverdict(pass);} else {setverdict(fail);}
51237 Overall verdict: pass
51243 .*---------------------------------------------------------------------*
51244 :h3. DECODING OBJECT IDENTIFIER , CER+DER, itu-t(0) recommendation(0) ,(primitive)
51245 .*---------------------------------------------------------------------*
51248 <TC - DECODING OBJECT IDENTIFIER , CER+DER, itu-t(0) recommendation(0) ,(primitive)>
51256 BERPDU ::= OBJECT IDENTIFIER
51258 myValue BERPDU ::= { itu-t(0) recommendation(0) a(2) b(3)}
51264 import from TempA all;
51266 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51271 if (dec_BER_PDU('0603000203'O) == myValue)
51274 {setverdict(pass);} else {setverdict(fail);}
51279 Overall verdict: pass
51285 .*---------------------------------------------------------------------*
51286 :h3. DECODING OBJECT IDENTIFIER , CER+DER, itu-t recommendation ,(primitive)
51287 .*---------------------------------------------------------------------*
51290 <TC - DECODING OBJECT IDENTIFIER , CER+DER, itu-t recommendation ,(primitive)>
51298 BERPDU ::= OBJECT IDENTIFIER
51300 myValue BERPDU ::= {itu-t recommendation a(2) b(3)}
51306 import from TempA all;
51308 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51313 if (dec_BER_PDU('0603000203'O) == myValue)
51316 {setverdict(pass);} else {setverdict(fail);}
51321 Overall verdict: pass
51327 .*---------------------------------------------------------------------*
51328 :h3. DECODING OBJECT IDENTIFIER , CER+DER 0 0 ,(primitive)
51329 .*---------------------------------------------------------------------*
51332 <TC - DECODING OBJECT IDENTIFIER , CER+DER 0 0 ,(primitive)>
51340 BERPDU ::= OBJECT IDENTIFIER
51342 myValue BERPDU ::= {0 0 a(2) b(3)}
51348 import from TempA all;
51350 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51355 if (dec_BER_PDU('0603000203'O) == myValue)
51358 {setverdict(pass);} else {setverdict(fail);}
51363 Overall verdict: pass
51369 .*---------------------------------------------------------------------*
51370 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) question(1) ,(primitive)
51371 .*---------------------------------------------------------------------*
51374 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) question(1) ,(primitive)>
51382 BERPDU ::= OBJECT IDENTIFIER
51384 myValue BERPDU ::= {itu-t(0) question(1) a(2) b(3)}
51390 import from TempA all;
51392 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51397 if (dec_BER_PDU('0603010203'O) == myValue)
51400 {setverdict(pass);} else {setverdict(fail);}
51405 Overall verdict: pass
51411 .*---------------------------------------------------------------------*
51412 :h3. DECODING OBJECT IDENTIFIER , CER+DER, itu-t question ,(primitive)
51413 .*---------------------------------------------------------------------*
51416 <TC - DECODING OBJECT IDENTIFIER , CER+DER, itu-t question ,(primitive)>
51424 BERPDU ::= OBJECT IDENTIFIER
51426 myValue BERPDU ::= {itu-t question a(2) b(3)}
51432 import from TempA all;
51434 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51439 if (dec_BER_PDU('0603010203'O) == myValue)
51442 {setverdict(pass);} else {setverdict(fail);}
51447 Overall verdict: pass
51453 .*---------------------------------------------------------------------*
51454 :h3. DECODING OBJECT IDENTIFIER , CER+DER 0 1 ,(primitive)
51455 .*---------------------------------------------------------------------*
51458 <TC - DECODING OBJECT IDENTIFIER , CER+DER 0 1 ,(primitive)>
51466 BERPDU ::= OBJECT IDENTIFIER
51468 myValue BERPDU ::= {0 1 a(2) b(3)}
51474 import from TempA all;
51476 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51481 if (dec_BER_PDU('0603010203'O) == myValue)
51484 {setverdict(pass);} else {setverdict(fail);}
51489 Overall verdict: pass
51495 .*---------------------------------------------------------------------*
51496 :h3. DECODING OBJECT IDENTIFIER , CER+DER , itu-t(0) administration(2) ,(primitive)
51497 .*---------------------------------------------------------------------*
51500 <TC - DECODING OBJECT IDENTIFIER , CER+DER , itu-t(0) administration(2) ,(primitive)>
51508 BERPDU ::= OBJECT IDENTIFIER
51510 myValue BERPDU ::= {itu-t(0) administration(2) a(2) b(3)}
51516 import from TempA all;
51518 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51523 if (dec_BER_PDU('0603020203'O) == myValue)
51526 {setverdict(pass);} else {setverdict(fail);}
51531 Overall verdict: pass
51537 .*---------------------------------------------------------------------*
51538 :h3. DECODING OBJECT IDENTIFIER , CER+DER , itu-t administration ,(primitive)
51539 .*---------------------------------------------------------------------*
51542 <TC - DECODING OBJECT IDENTIFIER , CER+DER , itu-t administration ,(primitive)>
51550 BERPDU ::= OBJECT IDENTIFIER
51552 myValue BERPDU ::= {itu-t administration a(2) b(3)}
51558 import from TempA all;
51560 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51565 if (dec_BER_PDU('0603020203'O) == myValue)
51568 {setverdict(pass);} else {setverdict(fail);}
51573 Overall verdict: pass
51579 .*---------------------------------------------------------------------*
51580 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,0 2 ,(primitive)
51581 .*---------------------------------------------------------------------*
51584 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,0 2 ,(primitive)>
51592 BERPDU ::= OBJECT IDENTIFIER
51594 myValue BERPDU ::= {0 2 a(2) b(3)}
51600 import from TempA all;
51602 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51607 if (dec_BER_PDU('0603020203'O) == myValue)
51610 {setverdict(pass);} else {setverdict(fail);}
51615 Overall verdict: pass
51621 .*---------------------------------------------------------------------*
51622 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) network-operator(3) ,(primitive)
51623 .*---------------------------------------------------------------------*
51626 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) network-operator(3) ,(primitive)>
51634 BERPDU ::= OBJECT IDENTIFIER
51636 myValue BERPDU ::= {itu-t(0) network-operator(3) a(2) b(3)}
51642 import from TempA all;
51644 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51649 if (dec_BER_PDU('0603030203'O) == myValue)
51652 {setverdict(pass);} else {setverdict(fail);}
51657 Overall verdict: pass
51663 .*---------------------------------------------------------------------*
51664 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t network-operator ,(primitive)
51665 .*---------------------------------------------------------------------*
51668 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t network-operator ,(primitive)>
51676 BERPDU ::= OBJECT IDENTIFIER
51678 myValue BERPDU ::= {itu-t network-operator a(2) b(3)}
51684 import from TempA all;
51686 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51691 if (dec_BER_PDU('0603030203'O) == myValue)
51694 {setverdict(pass);} else {setverdict(fail);}
51699 Overall verdict: pass
51705 .*---------------------------------------------------------------------*
51706 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,0 3 ,(primitive)
51707 .*---------------------------------------------------------------------*
51710 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,0 3 ,(primitive)>
51718 BERPDU ::= OBJECT IDENTIFIER
51720 myValue BERPDU ::= {0 3 a(2) b(3)}
51726 import from TempA all;
51728 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51733 if (dec_BER_PDU('0603030203'O) == myValue)
51736 {setverdict(pass);} else {setverdict(fail);}
51741 Overall verdict: pass
51747 .*---------------------------------------------------------------------*
51748 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) identified-organization(4) ,(primitive)
51749 .*---------------------------------------------------------------------*
51752 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) identified-organization(4) ,(primitive)>
51760 BERPDU ::= OBJECT IDENTIFIER
51762 myValue BERPDU ::= {itu-t(0) identified-organization(4) a(2) b(3)}
51768 import from TempA all;
51770 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51775 if (dec_BER_PDU('0603040203'O) == myValue)
51778 {setverdict(pass);} else {setverdict(fail);}
51783 Overall verdict: pass
51789 .*---------------------------------------------------------------------*
51790 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t identified-organization ,(primitive)
51791 .*---------------------------------------------------------------------*
51794 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t identified-organization ,(primitive)>
51802 BERPDU ::= OBJECT IDENTIFIER
51804 myValue BERPDU ::= {itu-t identified-organization a(2) b(3)}
51810 import from TempA all;
51812 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51817 if (dec_BER_PDU('0603040203'O) == myValue)
51820 {setverdict(pass);} else {setverdict(fail);}
51825 Overall verdict: pass
51831 .*---------------------------------------------------------------------*
51832 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,0 4 ,(primitive)
51833 .*---------------------------------------------------------------------*
51836 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,0 4 ,(primitive)>
51844 BERPDU ::= OBJECT IDENTIFIER
51846 myValue BERPDU ::= {0 4 a(2) b(3)}
51852 import from TempA all;
51854 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51859 if (dec_BER_PDU('0603040203'O) == myValue)
51862 {setverdict(pass);} else {setverdict(fail);}
51867 Overall verdict: pass
51873 .*---------------------------------------------------------------------*
51874 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) standard(0) ,(primitive)
51875 .*---------------------------------------------------------------------*
51878 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) standard(0) ,(primitive)>
51886 BERPDU ::= OBJECT IDENTIFIER
51888 myValue BERPDU ::= {iso(1) standard(0) a(2) b(3)}
51894 import from TempA all;
51896 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51901 if (dec_BER_PDU('0603280203'O) == myValue)
51904 {setverdict(pass);} else {setverdict(fail);}
51909 Overall verdict: pass
51915 .*---------------------------------------------------------------------*
51916 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso standard ,(primitive)
51917 .*---------------------------------------------------------------------*
51920 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso standard ,(primitive)>
51928 BERPDU ::= OBJECT IDENTIFIER
51930 myValue BERPDU ::= {iso standard a(2) b(3)}
51936 import from TempA all;
51938 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51943 if (dec_BER_PDU('0603280203'O) == myValue)
51946 {setverdict(pass);} else {setverdict(fail);}
51951 Overall verdict: pass
51957 .*---------------------------------------------------------------------*
51958 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,1 0 ,(primitive)
51959 .*---------------------------------------------------------------------*
51962 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,1 0 ,(primitive)>
51970 BERPDU ::= OBJECT IDENTIFIER
51972 myValue BERPDU ::= {1 0 a(2) b(3)}
51978 import from TempA all;
51980 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
51985 if (dec_BER_PDU('0603280203'O) == myValue)
51988 {setverdict(pass);} else {setverdict(fail);}
51993 Overall verdict: pass
51999 .*---------------------------------------------------------------------*
52000 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) member-body(2) ,(primitive)
52001 .*---------------------------------------------------------------------*
52004 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) member-body(2) ,(primitive)>
52012 BERPDU ::= OBJECT IDENTIFIER
52014 myValue BERPDU ::= {iso(1) member-body(2) a(2) b(3)}
52020 import from TempA all;
52022 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52027 if (dec_BER_PDU('06032A0203'O) == myValue)
52030 {setverdict(pass);} else {setverdict(fail);}
52035 Overall verdict: pass
52041 .*---------------------------------------------------------------------*
52042 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso member-body ,(primitive)
52043 .*---------------------------------------------------------------------*
52046 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso member-body ,(primitive)>
52054 BERPDU ::= OBJECT IDENTIFIER
52056 myValue BERPDU ::= {iso member-body a(2) b(3)}
52062 import from TempA all;
52064 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52069 if (dec_BER_PDU('06032A0203'O) == myValue)
52072 {setverdict(pass);} else {setverdict(fail);}
52077 Overall verdict: pass
52083 .*---------------------------------------------------------------------*
52084 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,1 2 ,(primitive)
52085 .*---------------------------------------------------------------------*
52088 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,1 2 ,(primitive)>
52096 BERPDU ::= OBJECT IDENTIFIER
52098 myValue BERPDU ::= {1 2 a(2) b(3)}
52104 import from TempA all;
52106 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52111 if (dec_BER_PDU('06032A0203'O) == myValue)
52114 {setverdict(pass);} else {setverdict(fail);}
52119 Overall verdict: pass
52125 .*---------------------------------------------------------------------*
52126 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) identified-organization(3) ,(primitive)
52127 .*---------------------------------------------------------------------*
52130 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) identified-organization(3) ,(primitive)>
52138 BERPDU ::= OBJECT IDENTIFIER
52140 myValue BERPDU ::= {iso(1) identified-organization(3) a(2) b(3)}
52146 import from TempA all;
52148 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52153 if (dec_BER_PDU('06032B0203'O) == myValue)
52156 {setverdict(pass);} else {setverdict(fail);}
52161 Overall verdict: pass
52167 .*---------------------------------------------------------------------*
52168 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso identified-organization ,(primitive)
52169 .*---------------------------------------------------------------------*
52172 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso identified-organization ,(primitive)>
52180 BERPDU ::= OBJECT IDENTIFIER
52182 myValue BERPDU ::= {iso identified-organization a(2) b(3)}
52188 import from TempA all;
52190 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52195 if (dec_BER_PDU('06032B0203'O) == myValue)
52198 {setverdict(pass);} else {setverdict(fail);}
52203 Overall verdict: pass
52209 .*---------------------------------------------------------------------*
52210 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,1 3 ,(primitive)
52211 .*---------------------------------------------------------------------*
52214 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,1 3 ,(primitive)>
52222 BERPDU ::= OBJECT IDENTIFIER
52224 myValue BERPDU ::= {1 3 a(2) b(3)}
52230 import from TempA all;
52232 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52237 if (dec_BER_PDU('06032B0203'O) == myValue)
52240 {setverdict(pass);} else {setverdict(fail);}
52245 Overall verdict: pass
52251 .*---------------------------------------------------------------------*
52252 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(0) ,(primitive)
52253 .*---------------------------------------------------------------------*
52256 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(0) ,(primitive)>
52264 BERPDU ::= OBJECT IDENTIFIER
52266 myValue BERPDU ::= {joint-iso-itu-t(2) something(0) a(2) b(3)}
52272 import from TempA all;
52274 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52279 if (dec_BER_PDU('0603500203'O) == myValue)
52282 {setverdict(pass);} else {setverdict(fail);}
52287 Overall verdict: pass
52293 .*---------------------------------------------------------------------*
52294 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t something(0) ,(primitive)
52295 .*---------------------------------------------------------------------*
52298 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t something(0) ,(primitive)>
52306 BERPDU ::= OBJECT IDENTIFIER
52308 myValue BERPDU ::= {joint-iso-itu-t something(0) a(2) b(3)}
52315 import from TempA all;
52317 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52322 if (dec_BER_PDU('0603500203'O) == myValue)
52325 {setverdict(pass);} else {setverdict(fail);}
52330 Overall verdict: pass
52336 .*---------------------------------------------------------------------*
52337 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,2 0 ,(primitive)
52338 .*---------------------------------------------------------------------*
52341 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,2 0 ,(primitive)>
52349 BERPDU ::= OBJECT IDENTIFIER
52351 myValue BERPDU ::= {2 0 a(2) b(3)}
52357 import from TempA all;
52359 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52364 if (dec_BER_PDU('0603500203'O) == myValue)
52367 {setverdict(pass);} else {setverdict(fail);}
52372 Overall verdict: pass
52378 .*---------------------------------------------------------------------*
52379 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(100) ,(primitive)
52380 .*---------------------------------------------------------------------*
52383 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(100) ,(primitive)>
52391 BERPDU ::= OBJECT IDENTIFIER
52393 myValue BERPDU ::= {joint-iso-itu-t(2) something(100) a(2) b(3)}
52399 import from TempA all;
52401 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52406 if (dec_BER_PDU('060481340203'O) == myValue)
52409 {setverdict(pass);} else {setverdict(fail);}
52414 Overall verdict: pass
52420 .*---------------------------------------------------------------------*
52421 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(100) ,(primitive)
52422 .*---------------------------------------------------------------------*
52425 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(100) ,(primitive)>
52433 BERPDU ::= OBJECT IDENTIFIER
52435 myValue BERPDU ::= {joint-iso-itu-t 100 a(2) b(3)}
52441 import from TempA all;
52443 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52448 if (dec_BER_PDU('060481340203'O) == myValue)
52451 {setverdict(pass);} else {setverdict(fail);}
52456 Overall verdict: pass
52462 .*---------------------------------------------------------------------*
52463 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,2 100 ,(primitive)
52464 .*---------------------------------------------------------------------*
52467 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,2 100 ,(primitive)>
52475 BERPDU ::= OBJECT IDENTIFIER
52477 myValue BERPDU ::= {2 100 a(2) b(3)}
52483 import from TempA all;
52485 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52490 if (dec_BER_PDU('060481340203'O) == myValue)
52493 {setverdict(pass);} else {setverdict(fail);}
52498 Overall verdict: pass
52504 .*---------------------------------------------------------------------*
52505 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,multiple octets needed for values ,(primitive)
52506 .*---------------------------------------------------------------------*
52509 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,multiple octets needed for values ,(primitive)>
52517 BERPDU ::= OBJECT IDENTIFIER
52519 myValue BERPDU ::= {joint-iso-itu-t(2) something(0) a(2) b(3) 2000 4000 }
52525 import from TempA all;
52527 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52532 if (dec_BER_PDU('06075002038F509F20'O) == myValue)
52535 {setverdict(pass);} else {setverdict(fail);}
52540 Overall verdict: pass
52546 .*---------------------------------------------------------------------*
52547 :h3. DECODING OBJECT IDENTIFIER , CER+DER ,0 0, IMPLICIT, primitive
52548 .*---------------------------------------------------------------------*
52551 <TC - DECODING OBJECT IDENTIFIER , CER+DER ,0 0, IMPLICIT, primitive>
52559 BERPDU ::= [0] IMPLICIT OBJECT IDENTIFIER
52561 myValue BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)}
52567 import from TempA all;
52569 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52574 if (dec_BER_PDU('8003000203'O) == myValue)
52577 {setverdict(pass);} else {setverdict(fail);}
52582 Overall verdict: pass
52588 .*---------------------------------------------------------------------*
52589 :h3. DECODING OBJECT IDENTIFIER , DER ,0 0, EXPLICIT, constructed
52590 .*---------------------------------------------------------------------*
52593 <TC - DECODING OBJECT IDENTIFIER , DER ,0 0, EXPLICIT, constructed>
52601 BERPDU ::= [0] EXPLICIT OBJECT IDENTIFIER
52603 myValue BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)}
52609 import from TempA all;
52611 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52616 if (dec_BER_PDU('A0050603000203'O) == myValue)
52620 {setverdict(pass);} else {setverdict(fail);}
52625 Overall verdict: pass
52631 .*---------------------------------------------------------------------*
52632 :h3. DECODING OBJECT IDENTIFIER , CER ,0 0, EXPLICIT, constructed
52633 .*---------------------------------------------------------------------*
52636 <TC - DECODING OBJECT IDENTIFIER , CER ,0 0, EXPLICIT, constructed>
52644 BERPDU ::= [0] EXPLICIT OBJECT IDENTIFIER
52646 myValue BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)}
52652 import from TempA all;
52654 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
52659 if (dec_BER_PDU('A08006030002030000'O) == myValue)
52661 {setverdict(pass);} else {setverdict(fail);}
52666 Overall verdict: pass
52672 .*---------------------------------------------------------------------*
52673 :h3. CER + DER encoding of OPEN TYPE from Information Object Class
52674 .*---------------------------------------------------------------------*
52677 <TC - CER + DER encoding of OPEN TYPE from Information Object Class>
52687 --***************************************************************************************************
52688 --modified class taken from Gyuri ASN1
52689 --***************************************************************************************************
52690 MY-CLASS-1 ::= CLASS
52692 &TypeField OPTIONAL,
52693 &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL
52698 [TYPE FIELD &TypeField]
52699 [FIXED VALUE TYPE FIELD &fixedTypeValueField]
52702 ASN1-Type1 ::= INTEGER
52704 ASN1-Type2 ::= BOOLEAN
52706 ASN1-Type3 ::= SEQUENCE {f1 INTEGER}
52708 ASN1-Type4 ::= OCTET STRING
52711 --****************************************************************************************************
52712 -- OBJECTS using the class defined above
52713 --****************************************************************************************************
52716 myObject-1 MY-CLASS-1 ::=
52718 TYPE FIELD ASN1-Type3
52719 FIXED VALUE TYPE FIELD 999
52723 myObject-2 MY-CLASS-1 ::=
52725 TYPE FIELD ASN1-Type2
52726 FIXED VALUE TYPE FIELD 888
52729 myObject-3 MY-CLASS-1 ::=
52731 TYPE FIELD ASN1-Type4
52732 FIXED VALUE TYPE FIELD 555
52735 --****************************************************************************************************
52736 -- Defining Information Object sets
52737 --****************************************************************************************************
52739 MyInformationObjectSet1 MY-CLASS-1 ::=
52746 MyInformationObjectSet2 MY-CLASS-1 ::=
52748 MyInformationObjectSet1|
52753 BERPDU ::= SEQUENCE
52756 field1 MY-CLASS-1.&TypeField ({MyInformationObjectSet1} {@.field2} ),
52757 field2 MY-CLASS-1.&fixedTypeValueField ({MyInformationObjectSet1})
52765 import from TempA all;
52766 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
52767 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
52769 const BERPDU myValue := { field1 := {aSN1_Type3 := {f1 := 8}},field2 := 999 };
52774 if ((enc_DER_PDU(myValue) == '30093003020108020203E7'O)and(enc_CER_PDU(myValue) == '308030800201080000020203E70000'O)) {setverdict(pass);} else {setverdict(fail);}
52779 Overall verdict: pass
52785 .*---------------------------------------------------------------------*
52786 :h3. CER + DER encoding of TYPE from Information Object
52787 .*---------------------------------------------------------------------*
52790 <TC - CER + DER encoding of TYPE from Information Object >
52804 --***************************************************************************************************
52805 --modified class taken from Gyuri ASN1
52806 --***************************************************************************************************
52807 MY-CLASS-1 ::= CLASS
52809 &TypeField OPTIONAL,
52810 &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL
52815 [TYPE FIELD &TypeField]
52816 [FIXED VALUE TYPE FIELD &fixedTypeValueField]
52819 ASN1-Type1 ::= INTEGER
52821 ASN1-Type2 ::= BOOLEAN
52823 ASN1-Type3 ::= SEQUENCE {f1 INTEGER}
52825 ASN1-Type4 ::= OCTET STRING
52828 --****************************************************************************************************
52829 -- OBJECTS using the class defined above
52830 --****************************************************************************************************
52833 myObject-1 MY-CLASS-1 ::=
52835 TYPE FIELD ASN1-Type3
52836 FIXED VALUE TYPE FIELD 999
52840 myObject-2 MY-CLASS-1 ::=
52842 TYPE FIELD ASN1-Type2
52843 FIXED VALUE TYPE FIELD 888
52846 myObject-3 MY-CLASS-1 ::=
52848 TYPE FIELD ASN1-Type4
52849 FIXED VALUE TYPE FIELD 555
52852 --****************************************************************************************************
52853 -- Defining Information Object sets
52854 --****************************************************************************************************
52856 MyInformationObjectSet1 MY-CLASS-1 ::=
52863 MyInformationObjectSet2 MY-CLASS-1 ::=
52865 MyInformationObjectSet1|
52872 BERPDU ::= SEQUENCE
52875 field1 myObject-1.&TypeField , -- type from object
52876 field2 MY-CLASS-1.&fixedTypeValueField
52884 import from TempA all;
52885 external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
52886 external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" }
52888 const BERPDU myValue := { field1 := {f1 := 8},field2 := 999 };
52893 if ((enc_DER_PDU(myValue) == '30093003020108020203E7'O)and(enc_CER_PDU(myValue) == '308030800201080000020203E70000'O)) {setverdict(pass);} else {setverdict(fail);}
52898 Overall verdict: pass
52904 .*---------------------------------------------------------------------*
52905 :h3. DECODING ,OPEN TYPE, DER, from Information Object Class
52906 .*---------------------------------------------------------------------*
52909 <TC - DECODING ,OPEN TYPE, DER, from Information Object Class>
52920 --***************************************************************************************************
52921 --modified class taken from Gyuri ASN1
52922 --***************************************************************************************************
52923 MY-CLASS-1 ::= CLASS
52925 &TypeField OPTIONAL,
52926 &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL
52931 [TYPE FIELD &TypeField]
52932 [FIXED VALUE TYPE FIELD &fixedTypeValueField]
52935 ASN1-Type1 ::= INTEGER
52937 ASN1-Type2 ::= BOOLEAN
52939 ASN1-Type3 ::= SEQUENCE {f1 INTEGER}
52941 ASN1-Type4 ::= OCTET STRING
52944 --****************************************************************************************************
52945 -- OBJECTS using the class defined above
52946 --****************************************************************************************************
52949 myObject-1 MY-CLASS-1 ::=
52951 TYPE FIELD ASN1-Type3
52952 FIXED VALUE TYPE FIELD 999
52956 myObject-2 MY-CLASS-1 ::=
52958 TYPE FIELD ASN1-Type2
52959 FIXED VALUE TYPE FIELD 888
52962 myObject-3 MY-CLASS-1 ::=
52964 TYPE FIELD ASN1-Type4
52965 FIXED VALUE TYPE FIELD 555
52968 --****************************************************************************************************
52969 -- Defining Information Object sets
52970 --****************************************************************************************************
52972 MyInformationObjectSet1 MY-CLASS-1 ::=
52979 MyInformationObjectSet2 MY-CLASS-1 ::=
52981 MyInformationObjectSet1|
52986 BERPDU ::= SEQUENCE
52989 field1 MY-CLASS-1.&TypeField ({MyInformationObjectSet1} {@.field2} ),
52990 field2 MY-CLASS-1.&fixedTypeValueField ({MyInformationObjectSet1})
52997 import from TempA all;
52999 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
53001 const BERPDU myValue := { field1 := {aSN1_Type3 := {f1 := 8}}, field2 := 999};
53006 if (dec_BER_PDU('30093003020108020203E7'O) == myValue)
53008 {setverdict(pass);} else {setverdict(fail);}
53013 Overall verdict: pass
53019 .*---------------------------------------------------------------------*
53020 :h3. DECODING ,OPEN TYPE, CER, from Information Object Class
53021 .*---------------------------------------------------------------------*
53024 <TC - DECODING ,OPEN TYPE, CER, from Information Object Class>
53035 --***************************************************************************************************
53036 --modified class taken from Gyuri ASN1
53037 --***************************************************************************************************
53038 MY-CLASS-1 ::= CLASS
53040 &TypeField OPTIONAL,
53041 &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL
53046 [TYPE FIELD &TypeField]
53047 [FIXED VALUE TYPE FIELD &fixedTypeValueField]
53050 ASN1-Type1 ::= INTEGER
53052 ASN1-Type2 ::= BOOLEAN
53054 ASN1-Type3 ::= SEQUENCE {f1 INTEGER}
53056 ASN1-Type4 ::= OCTET STRING
53059 --****************************************************************************************************
53060 -- OBJECTS using the class defined above
53061 --****************************************************************************************************
53064 myObject-1 MY-CLASS-1 ::=
53066 TYPE FIELD ASN1-Type3
53067 FIXED VALUE TYPE FIELD 999
53071 myObject-2 MY-CLASS-1 ::=
53073 TYPE FIELD ASN1-Type2
53074 FIXED VALUE TYPE FIELD 888
53077 myObject-3 MY-CLASS-1 ::=
53079 TYPE FIELD ASN1-Type4
53080 FIXED VALUE TYPE FIELD 555
53083 --****************************************************************************************************
53084 -- Defining Information Object sets
53085 --****************************************************************************************************
53087 MyInformationObjectSet1 MY-CLASS-1 ::=
53094 MyInformationObjectSet2 MY-CLASS-1 ::=
53096 MyInformationObjectSet1|
53101 BERPDU ::= SEQUENCE
53104 field1 MY-CLASS-1.&TypeField ({MyInformationObjectSet1} {@.field2} ),
53105 field2 MY-CLASS-1.&fixedTypeValueField ({MyInformationObjectSet1})
53112 import from TempA all;
53114 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
53116 const BERPDU myValue := { field1 := {aSN1_Type3 := {f1 := 8}}, field2 := 999};
53121 if (dec_BER_PDU('308030800201080000020203E70000'O) == myValue)
53123 {setverdict(pass);} else {setverdict(fail);}
53128 Overall verdict: pass
53134 .*---------------------------------------------------------------------*
53135 :h3. DECODING , TYPE from Information Object Class, DER
53136 .*---------------------------------------------------------------------*
53139 <TC - DECODING , TYPE from Information Object Class, DER>
53154 --***************************************************************************************************
53155 --modified class taken from Gyuri ASN1
53156 --***************************************************************************************************
53157 MY-CLASS-1 ::= CLASS
53159 &TypeField OPTIONAL,
53160 &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL
53165 [TYPE FIELD &TypeField]
53166 [FIXED VALUE TYPE FIELD &fixedTypeValueField]
53169 ASN1-Type1 ::= INTEGER
53171 ASN1-Type2 ::= BOOLEAN
53173 ASN1-Type3 ::= SEQUENCE {f1 INTEGER}
53175 ASN1-Type4 ::= OCTET STRING
53178 --****************************************************************************************************
53179 -- OBJECTS using the class defined above
53180 --****************************************************************************************************
53183 myObject-1 MY-CLASS-1 ::=
53185 TYPE FIELD ASN1-Type3
53186 FIXED VALUE TYPE FIELD 999
53190 myObject-2 MY-CLASS-1 ::=
53192 TYPE FIELD ASN1-Type2
53193 FIXED VALUE TYPE FIELD 888
53196 myObject-3 MY-CLASS-1 ::=
53198 TYPE FIELD ASN1-Type4
53199 FIXED VALUE TYPE FIELD 555
53202 --****************************************************************************************************
53203 -- Defining Information Object sets
53204 --****************************************************************************************************
53206 MyInformationObjectSet1 MY-CLASS-1 ::=
53213 MyInformationObjectSet2 MY-CLASS-1 ::=
53215 MyInformationObjectSet1|
53222 BERPDU ::= SEQUENCE
53225 field1 myObject-1.&TypeField , -- type from object
53226 field2 MY-CLASS-1.&fixedTypeValueField
53233 import from TempA all;
53235 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
53237 const BERPDU myValue := { field1 := {f1 := 8}, field2 := 999};
53242 if (dec_BER_PDU('30093003020108020203E7'O) == myValue)
53244 {setverdict(pass);} else {setverdict(fail);}
53249 Overall verdict: pass
53255 .*---------------------------------------------------------------------*
53256 :h3. DECODING , TYPE from Information Object Class, CER
53257 .*---------------------------------------------------------------------*
53260 <TC - DECODING , TYPE from Information Object Class, CER>
53275 --***************************************************************************************************
53276 --modified class taken from Gyuri ASN1
53277 --***************************************************************************************************
53278 MY-CLASS-1 ::= CLASS
53280 &TypeField OPTIONAL,
53281 &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL
53286 [TYPE FIELD &TypeField]
53287 [FIXED VALUE TYPE FIELD &fixedTypeValueField]
53290 ASN1-Type1 ::= INTEGER
53292 ASN1-Type2 ::= BOOLEAN
53294 ASN1-Type3 ::= SEQUENCE {f1 INTEGER}
53296 ASN1-Type4 ::= OCTET STRING
53299 --****************************************************************************************************
53300 -- OBJECTS using the class defined above
53301 --****************************************************************************************************
53304 myObject-1 MY-CLASS-1 ::=
53306 TYPE FIELD ASN1-Type3
53307 FIXED VALUE TYPE FIELD 999
53311 myObject-2 MY-CLASS-1 ::=
53313 TYPE FIELD ASN1-Type2
53314 FIXED VALUE TYPE FIELD 888
53317 myObject-3 MY-CLASS-1 ::=
53319 TYPE FIELD ASN1-Type4
53320 FIXED VALUE TYPE FIELD 555
53323 --****************************************************************************************************
53324 -- Defining Information Object sets
53325 --****************************************************************************************************
53327 MyInformationObjectSet1 MY-CLASS-1 ::=
53334 MyInformationObjectSet2 MY-CLASS-1 ::=
53336 MyInformationObjectSet1|
53343 BERPDU ::= SEQUENCE
53346 field1 myObject-1.&TypeField , -- type from object
53347 field2 MY-CLASS-1.&fixedTypeValueField
53354 import from TempA all;
53356 external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" }
53358 const BERPDU myValue := { field1 := {f1 := 8}, field2 := 999};
53363 if (dec_BER_PDU('308030800201080000020203E70000'O) == myValue)
53365 {setverdict(pass);} else {setverdict(fail);}
53370 Overall verdict: pass
53377 .*---------------------------------------------------------------------*
53378 :h2.Testing Enc/Dec functions of implicit message encoding
53379 .*---------------------------------------------------------------------*
53380 .*---------------------------------------------------------------------*
53381 :h3. Fast enc/dec function
53382 .*---------------------------------------------------------------------*
53385 <TC- Implicit message encoding: prototype fast>
53394 BERPDU ::= SEQUENCE
53407 import from TempA all;
53408 external function enc_DER_PDU(in BERPDU pdu, out octetstring os) with { extension "prototype(fast) encode(BER:BER_ENCODE_DER)" }
53409 external function enc_CER_PDU(in BERPDU pdu, out octetstring os) with { extension "prototype(fast) encode(BER:BER_ENCODE_CER)" }
53410 external function dec_BER_PDU(in octetstring os, out BERPDU pdu)
53411 with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53413 const BERPDU myValue := {
53421 var octetstring der_encoded, cer_encoded;
53422 var BERPDU der_decoded, cer_decoded;
53424 enc_DER_PDU(myValue, der_encoded);
53425 enc_CER_PDU(myValue, cer_encoded);
53427 if ((der_encoded == '300D8001FF8101FF83020780820104'O) and
53428 (cer_encoded == '30808001FF8101FF830207808201040000'O))
53429 {setverdict(pass);} else {setverdict(fail);}
53431 dec_BER_PDU(der_encoded, der_decoded);
53432 if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);}
53433 dec_BER_PDU(cer_encoded, cer_decoded);
53434 if (cer_decoded==myValue) {setverdict(pass);} else {setverdict(fail);}
53438 Overall verdict: pass
53444 .*---------------------------------------------------------------------*
53445 :h3. Backtrack decode function
53446 .*---------------------------------------------------------------------*
53449 <TC- Implicit message encoding: prototype backtrack>
53458 STRPDU ::= PrintableString
53459 USTRPDU ::= GeneralString
53460 SEQPDU ::= SEQUENCE {
53469 import from TempA all;
53471 external function encode_str(in STRPDU pdu) return octetstring
53472 with { extension "prototype(convert) encode(BER)" }
53473 external function encode_ustr(in USTRPDU updu) return octetstring
53474 with { extension "prototype(convert) encode(BER)" }
53475 external function encode_seq(in SEQPDU pdu) return octetstring
53476 with { extension "prototype(convert) encode(BER)" }
53477 external function decode_str(in octetstring os, out STRPDU pdu) return integer
53478 with { extension "prototype(backtrack) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53479 external function decode_ustr(in octetstring os, out USTRPDU pdu) return integer
53480 with { extension "prototype(backtrack) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53481 external function decode_seq(in octetstring os, out SEQPDU pdu) return integer
53482 with { extension "prototype(backtrack) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53486 var STRPDU str := "haha";
53487 var USTRPDU ustr := "uu";
53488 var SEQPDU seq := { 123, 'ABCDEF'O, true }
53489 var STRPDU decoded_str;
53490 var USTRPDU decoded_ustr;
53491 var SEQPDU decoded_seq;
53492 var integer ret_val;
53494 ret_val := decode_str(encode_str(str), decoded_str);
53495 if (ret_val==0 and decoded_str==str) {setverdict(pass);} else {setverdict(fail);}
53496 ret_val := decode_ustr(encode_ustr(ustr), decoded_ustr);
53497 if (ret_val==0 and decoded_ustr==ustr) {setverdict(pass);} else {setverdict(fail);}
53498 ret_val := decode_seq(encode_seq(seq), decoded_seq);
53499 if (ret_val==0 and decoded_seq==seq) {setverdict(pass);} else {setverdict(fail);}
53501 ret_val := decode_str(''O, decoded_str);
53502 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53503 ret_val := decode_ustr(''O, decoded_ustr);
53504 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53505 ret_val := decode_seq(''O, decoded_seq);
53506 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53508 ret_val := decode_str('12'O, decoded_str);
53509 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53510 ret_val := decode_ustr('12'O, decoded_ustr);
53511 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53512 ret_val := decode_seq('12'O, decoded_seq);
53513 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53515 ret_val := decode_str('1234'O, decoded_str);
53516 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53517 ret_val := decode_ustr('1234'O, decoded_ustr);
53518 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53519 ret_val := decode_seq('1234'O, decoded_seq);
53520 if (ret_val==1) {setverdict(pass);} else {setverdict(fail);}
53524 Overall verdict: pass
53530 .*---------------------------------------------------------------------*
53531 :h3. Sliding decode function
53532 .*---------------------------------------------------------------------*
53535 <TC- Implicit message encoding: prototype sliding>
53553 import from TempA all;
53555 external function encode_PDU(in PDU pdu) return octetstring
53556 with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53557 external function decode_PDU(inout octetstring os, out PDU pdu) return integer
53558 with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53562 var PDU pdu := { 123, 'ABCDEF'O, true }
53563 var octetstring encoded_pdu;
53564 var PDU decoded_pdu;
53565 var integer ret_val;
53567 encoded_pdu := encode_PDU(pdu);
53568 ret_val := decode_PDU(encoded_pdu, decoded_pdu);
53569 if (ret_val==0 and decoded_pdu==pdu) {setverdict(pass);} else {setverdict(fail);}
53571 encoded_pdu := '800100'O;
53572 ret_val := decode_PDU(encoded_pdu, decoded_pdu);
53573 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53575 encoded_pdu := substr(encode_PDU(pdu), 0, 4);
53576 ret_val := decode_PDU(encoded_pdu, decoded_pdu);
53577 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53581 Overall verdict: pass
53587 .*---------------------------------------------------------------------*
53588 :h3. Sliding decoding, octetstring length 0,1,2 -> incomplete TLV
53589 .*---------------------------------------------------------------------*
53592 <TC- Implicit message encoding: incomplete TLV>
53604 PDU3 ::= ENUMERATED { e0 (0), e1 (1) }
53606 PDU5 ::= BIT STRING
53607 PDU6 ::= OCTET STRING
53608 PDU7 ::= PrintableString
53609 PDU8 ::= GeneralString
53610 PDU9 ::= CHOICE { i INTEGER, b BOOLEAN }
53611 PDU10 ::= SEQUENCE { i INTEGER, b BOOLEAN }
53612 PDU11 ::= SEQUENCE OF INTEGER
53613 PDU12 ::= OBJECT IDENTIFIER
53618 import from TempA all;
53620 external function encode_PDU0(in PDU0 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53621 external function decode_PDU0(inout octetstring os, out PDU0 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53623 external function encode_PDU1(in PDU1 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53624 external function decode_PDU1(inout octetstring os, out PDU1 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53626 external function encode_PDU2(in PDU2 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53627 external function decode_PDU2(inout octetstring os, out PDU2 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53629 external function encode_PDU3(in PDU3 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53630 external function decode_PDU3(inout octetstring os, out PDU3 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53632 external function encode_PDU4(in PDU4 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53633 external function decode_PDU4(inout octetstring os, out PDU4 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53635 external function encode_PDU5(in PDU5 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53636 external function decode_PDU5(inout octetstring os, out PDU5 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53638 external function encode_PDU6(in PDU6 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53639 external function decode_PDU6(inout octetstring os, out PDU6 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53641 external function encode_PDU7(in PDU7 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53642 external function decode_PDU7(inout octetstring os, out PDU7 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53644 external function encode_PDU8(in PDU8 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53645 external function decode_PDU8(inout octetstring os, out PDU8 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53647 external function encode_PDU9(in PDU9 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53648 external function decode_PDU9(inout octetstring os, out PDU9 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53650 external function encode_PDU10(in PDU10 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53651 external function decode_PDU10(inout octetstring os, out PDU10 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53653 external function encode_PDU11(in PDU11 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53654 external function decode_PDU11(inout octetstring os, out PDU11 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53656 external function encode_PDU12(in PDU12 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
53657 external function decode_PDU12(inout octetstring os, out PDU12 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
53661 var octetstring encoded_pdu;
53662 var integer ret_val;
53664 var PDU0 pdu0 := NULL;
53665 var PDU0 decoded_pdu0;
53666 encoded_pdu := substr(encode_PDU0(pdu0), 0, 0);
53667 ret_val := decode_PDU0(encoded_pdu, decoded_pdu0);
53668 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53669 encoded_pdu := substr(encode_PDU0(pdu0), 0, 1);
53670 ret_val := decode_PDU0(encoded_pdu, decoded_pdu0);
53671 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53673 var PDU1 pdu1 := true;
53674 var PDU1 decoded_pdu1;
53675 encoded_pdu := substr(encode_PDU1(pdu1), 0, 0);
53676 ret_val := decode_PDU1(encoded_pdu, decoded_pdu1);
53677 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53678 encoded_pdu := substr(encode_PDU1(pdu1), 0, 1);
53679 ret_val := decode_PDU1(encoded_pdu, decoded_pdu1);
53680 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53681 encoded_pdu := substr(encode_PDU1(pdu1), 0, 2);
53682 ret_val := decode_PDU1(encoded_pdu, decoded_pdu1);
53683 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53685 var PDU2 pdu2 := 123;
53686 var PDU2 decoded_pdu2;
53687 encoded_pdu := substr(encode_PDU2(pdu2), 0, 0);
53688 ret_val := decode_PDU2(encoded_pdu, decoded_pdu2);
53689 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53690 encoded_pdu := substr(encode_PDU2(pdu2), 0, 1);
53691 ret_val := decode_PDU2(encoded_pdu, decoded_pdu2);
53692 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53693 encoded_pdu := substr(encode_PDU2(pdu2), 0, 2);
53694 ret_val := decode_PDU2(encoded_pdu, decoded_pdu2);
53695 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53697 var PDU3 pdu3 := e1;
53698 var PDU3 decoded_pdu3;
53699 encoded_pdu := substr(encode_PDU3(pdu3), 0, 0);
53700 ret_val := decode_PDU3(encoded_pdu, decoded_pdu3);
53701 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53702 encoded_pdu := substr(encode_PDU3(pdu3), 0, 1);
53703 ret_val := decode_PDU3(encoded_pdu, decoded_pdu3);
53704 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53705 encoded_pdu := substr(encode_PDU3(pdu3), 0, 2);
53706 ret_val := decode_PDU3(encoded_pdu, decoded_pdu3);
53707 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53709 var PDU4 pdu4 := 1.23;
53710 var PDU4 decoded_pdu4;
53711 encoded_pdu := substr(encode_PDU4(pdu4), 0, 0);
53712 ret_val := decode_PDU4(encoded_pdu, decoded_pdu4);
53713 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53714 encoded_pdu := substr(encode_PDU4(pdu4), 0, 1);
53715 ret_val := decode_PDU4(encoded_pdu, decoded_pdu4);
53716 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53717 encoded_pdu := substr(encode_PDU4(pdu4), 0, 2);
53718 ret_val := decode_PDU4(encoded_pdu, decoded_pdu4);
53719 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53721 var PDU5 pdu5 := '101010'B;
53722 var PDU5 decoded_pdu5;
53723 encoded_pdu := substr(encode_PDU5(pdu5), 0, 0);
53724 ret_val := decode_PDU5(encoded_pdu, decoded_pdu5);
53725 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53726 encoded_pdu := substr(encode_PDU5(pdu5), 0, 1);
53727 ret_val := decode_PDU5(encoded_pdu, decoded_pdu5);
53728 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53729 encoded_pdu := substr(encode_PDU5(pdu5), 0, 2);
53730 ret_val := decode_PDU5(encoded_pdu, decoded_pdu5);
53731 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53733 var PDU6 pdu6 := 'ABCDEF12'O;
53734 var PDU6 decoded_pdu6;
53735 encoded_pdu := substr(encode_PDU6(pdu6), 0, 0);
53736 ret_val := decode_PDU6(encoded_pdu, decoded_pdu6);
53737 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53738 encoded_pdu := substr(encode_PDU6(pdu6), 0, 1);
53739 ret_val := decode_PDU6(encoded_pdu, decoded_pdu6);
53740 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53741 encoded_pdu := substr(encode_PDU6(pdu6), 0, 2);
53742 ret_val := decode_PDU6(encoded_pdu, decoded_pdu6);
53743 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53745 var PDU7 pdu7 := "haha";
53746 var PDU7 decoded_pdu7;
53747 encoded_pdu := substr(encode_PDU7(pdu7), 0, 0);
53748 ret_val := decode_PDU7(encoded_pdu, decoded_pdu7);
53749 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53750 encoded_pdu := substr(encode_PDU7(pdu7), 0, 1);
53751 ret_val := decode_PDU7(encoded_pdu, decoded_pdu7);
53752 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53753 encoded_pdu := substr(encode_PDU7(pdu7), 0, 2);
53754 ret_val := decode_PDU7(encoded_pdu, decoded_pdu7);
53755 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53757 var PDU8 pdu8 := "huhu";
53758 var PDU8 decoded_pdu8;
53759 encoded_pdu := substr(encode_PDU8(pdu8), 0, 0);
53760 ret_val := decode_PDU8(encoded_pdu, decoded_pdu8);
53761 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53762 encoded_pdu := substr(encode_PDU8(pdu8), 0, 1);
53763 ret_val := decode_PDU8(encoded_pdu, decoded_pdu8);
53764 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53765 encoded_pdu := substr(encode_PDU8(pdu8), 0, 2);
53766 ret_val := decode_PDU8(encoded_pdu, decoded_pdu8);
53767 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53769 var PDU9 pdu9 := { b := true }
53770 var PDU9 decoded_pdu9;
53771 encoded_pdu := substr(encode_PDU9(pdu9), 0, 0);
53772 ret_val := decode_PDU9(encoded_pdu, decoded_pdu9);
53773 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53774 encoded_pdu := substr(encode_PDU9(pdu9), 0, 1);
53775 ret_val := decode_PDU9(encoded_pdu, decoded_pdu9);
53776 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53777 encoded_pdu := substr(encode_PDU9(pdu9), 0, 2);
53778 ret_val := decode_PDU9(encoded_pdu, decoded_pdu9);
53779 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53781 var PDU10 pdu10 := { 123 , true }
53782 var PDU10 decoded_pdu10;
53783 encoded_pdu := substr(encode_PDU10(pdu10), 0, 0);
53784 ret_val := decode_PDU10(encoded_pdu, decoded_pdu10);
53785 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53786 encoded_pdu := substr(encode_PDU10(pdu10), 0, 1);
53787 ret_val := decode_PDU10(encoded_pdu, decoded_pdu10);
53788 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53789 encoded_pdu := substr(encode_PDU10(pdu10), 0, 2);
53790 ret_val := decode_PDU10(encoded_pdu, decoded_pdu10);
53791 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53793 var PDU11 pdu11 := { 1, 2, 3 }
53794 var PDU11 decoded_pdu11;
53795 encoded_pdu := substr(encode_PDU11(pdu11), 0, 0);
53796 ret_val := decode_PDU11(encoded_pdu, decoded_pdu11);
53797 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53798 encoded_pdu := substr(encode_PDU11(pdu11), 0, 1);
53799 ret_val := decode_PDU11(encoded_pdu, decoded_pdu11);
53800 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53801 encoded_pdu := substr(encode_PDU11(pdu11), 0, 2);
53802 ret_val := decode_PDU11(encoded_pdu, decoded_pdu11);
53803 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53805 var PDU12 pdu12 := objid { itu_t(0) 4 }
53806 var PDU12 decoded_pdu12;
53807 encoded_pdu := substr(encode_PDU12(pdu12), 0, 0);
53808 ret_val := decode_PDU12(encoded_pdu, decoded_pdu12);
53809 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53810 encoded_pdu := substr(encode_PDU12(pdu12), 0, 1);
53811 ret_val := decode_PDU12(encoded_pdu, decoded_pdu12);
53812 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53813 encoded_pdu := substr(encode_PDU12(pdu12), 0, 2);
53814 ret_val := decode_PDU12(encoded_pdu, decoded_pdu12);
53815 if (ret_val==2) {setverdict(pass);} else {setverdict(fail);}
53819 Overall verdict: pass
53825 .*---------------------------------------------------------------------*
53826 :h2. Encoding/decoding of big integers
53827 .*---------------------------------------------------------------------*
53828 .*---------------------------------------------------------------------*
53829 :h3. Encoding/decoding of big integers
53830 .*---------------------------------------------------------------------*
53833 <TC - Encoding/decoding of big integers>
53837 TempA DEFINITIONS AUTOMATIC TAGS ::=
53844 bi4 BERPDU ::= -128
53846 bi-6 BERPDU ::= 128
53847 bi7 BERPDU ::= -129
53850 --b BERPDU2 ::= 12345678900
53852 Rec-ber ::= SEQUENCE {
53856 Rec-ber-literal ::= SEQUENCE {
53861 NumberLit ::= NumericString (SIZE (100))
53862 myNumber Number ::= 12345678910111213141516
53868 import from TempA language "ASN.1:1997" all
53870 external function enc_ber1(in Rec_ber r) return octetstring
53871 with { extension "encode(BER:BER_ENCODE_DER) prototype(convert) errorbehavior(ALL:WARNING)" }
53872 external function dec_ber1(in octetstring r) return Rec_ber
53873 with { extension "decode(BER:BER_ACCEPT_ALL) prototype(convert) errorbehavior(ALL:WARNING)" }
53874 external function enc_ber2(in integer r) return octetstring
53875 with { extension "encode(BER:BER_ENCODE_DER) prototype(convert) errorbehavior(ALL:WARNING)" }
53876 // Attributes are not checked in the compiler.
53877 external function dec_ber2(in octetstring r) return integer
53878 with { extension "decode(BER:BER_ENCODE_DER) prototype(convert) errorbehavior(ALL:WARNING)" }
53879 external function dec_ber3(inout octetstring r, out Rec_ber s) return integer
53880 with { extension "decode(BER:BER_ACCEPT_ALL) prototype(sliding) errorbehavior(ALL:WARNING)" }
53882 type component comp_ber { }
53886 const integer a := 2147483647
53887 const integer b := 2147483648
53888 const integer c := 2147483649
53889 const integer d := 128
53890 const integer e := myNumber
53891 const integer f := 12147483648
53892 var Rec_ber myrec1 := {int1 := a, int2 := b}
53893 var Rec_ber myrec2 := {int1 := c, int2 := d}
53894 var Rec_ber myrec3 := {int1 := 1048576, int2 := 321768}
53895 var Rec_ber myrec4 := {65536, 131072}
53896 var Rec_ber myrec5 := {4294967296, 8388608}
53897 var Rec_ber myrec6 := {12345678910111213141516, 11111111111111111111}
53898 var Rec_ber myrec7 := {8589934592, 1099511627776}
53899 var Rec_ber myrec8 := {int1 := a, int2 := b}
53900 var Rec_ber myrec9 := {int1 := 12345678910111213141516, int2 := -1234}
53901 var Rec_ber myrec10 := {int1 := -12345678910111213141516, int2 := -1234}
53902 var Rec_ber myrec11 := {2147483648, -2147483648}
53903 var Rec_ber myrec12 := {-2147483647, 2147483647}
53904 var Rec_ber myrec13 := {2147483649, -2147483649}
53905 var Rec_ber myrec14 := {-4294967296, 4294967296}
53906 var Rec_ber myrec15 := {4294967295, -4294967295}
53907 var Rec_ber myrec16 := {-4294967297, 4294967297}
53908 var Rec_ber pdu1 := {12345678910111213141516, -2147483648}
53909 var Rec_ber pdu2 := {123, 456}
53910 var octetstring encoded_pdu
53911 var Rec_ber decoded_pdu
53912 var integer ret_val
53913 encoded_pdu := enc_ber1(pdu2)
53914 ret_val := dec_ber3(encoded_pdu, decoded_pdu)
53915 if (ret_val == 0 and decoded_pdu == pdu2) {setverdict(pass)} else {setverdict(fail)}
53916 encoded_pdu := '800100'O
53917 ret_val := dec_ber3(encoded_pdu, decoded_pdu)
53918 if (ret_val == 2) {setverdict(pass)} else {setverdict(fail)}
53919 encoded_pdu := substr(enc_ber1(pdu1), 0, 4)
53920 ret_val := dec_ber3(encoded_pdu, decoded_pdu)
53921 if (ret_val == 2) {setverdict(pass)} else {setverdict(fail)}
53922 encoded_pdu := enc_ber2(-2147483648)
53923 if (encoded_pdu == '020480000000'O) {setverdict(pass)} else {setverdict(fail)}
53924 encoded_pdu := enc_ber1(myrec1)
53925 if (myrec1 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53926 if ({int1 := a, int2 := b} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53927 encoded_pdu := enc_ber1(myrec2)
53928 if (myrec2 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53929 if ({int1 := c, int2 := d} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53930 encoded_pdu := enc_ber1(myrec3)
53931 if (myrec3 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53932 if ({int1 := 1048576, int2 := 321768} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53933 encoded_pdu := enc_ber1(myrec4)
53934 if (myrec4 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53935 if ({65536, 131072} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53936 encoded_pdu := enc_ber1(myrec5)
53937 if (myrec5 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53938 if ({4294967296, 8388608} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53939 encoded_pdu := enc_ber1(myrec6)
53940 if (myrec6 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53941 if ({12345678910111213141516, 11111111111111111111} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53942 encoded_pdu := enc_ber1(myrec7)
53943 if (myrec7 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53944 if ({8589934592, 1099511627776} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53945 encoded_pdu := enc_ber1(myrec8)
53946 if (myrec8 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53947 if ({int1 := a, int2 := b} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53948 encoded_pdu := enc_ber1(myrec9)
53949 if (myrec9 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53950 if ({int1 := 12345678910111213141516, int2 := -1234} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53951 encoded_pdu := enc_ber1(myrec10)
53952 if (myrec10 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53953 if ({int1 := -12345678910111213141516, int2 := -1234} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53954 encoded_pdu := enc_ber1(myrec11)
53955 if (myrec11 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53956 if ({2147483648, -2147483648} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53957 encoded_pdu := enc_ber1(myrec12)
53958 if (myrec12 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53959 if ({-2147483647, 2147483647} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53960 encoded_pdu := enc_ber1(myrec13)
53961 if (myrec13 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53962 if ({2147483649, -2147483649} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53963 encoded_pdu := enc_ber1(myrec14)
53964 if (myrec14 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53965 if ({-4294967296, 4294967296} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53966 encoded_pdu := enc_ber1(myrec15)
53967 if (myrec15 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53968 if ({4294967295, -4294967295} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53969 encoded_pdu := enc_ber1(myrec16)
53970 if (myrec16 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53971 if ({-4294967297, 4294967297} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)}
53976 Overall verdict: pass
53982 .*---------------------------------------------------------------------*
53984 .*---------------------------------------------------------------------*
53985 Negative tests for the BER decoder.
53986 .*---------------------------------------------------------------------*
53988 .*---------------------------------------------------------------------*
53990 .*---------------------------------------------------------------------*
53991 :h3. BER decoding REAL, decimal form NR3 pretending to be NR1
53992 .*---------------------------------------------------------------------*
53995 <TC- BER decoding REAL, decimal form NR3 pretending to be NR1>
54005 IMPORTS; -- nothing
54015 external function dec_BER_PDU(in octetstring os, out BERPDU pdu)
54016 with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " }
54018 // pi: 31415926.E-7
54019 const octetstring der_encoded := '090D0133313431353932362E452D37'O;
54020 const BERPDU myValue := 3.1415926;
54024 var BERPDU der_decoded, cer_decoded;
54026 dec_BER_PDU(der_encoded, der_decoded);
54027 if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);}
54031 Dynamic test case error: While BER-decoding type '@Temp.BERPDU': While decoding REAL type: This decimal encoding does not conform to NR1 form.
54038 .*---------------------------------------------------------------------*
54039 :h3. BER decoding REAL, decimal form NR3 pretending to be NR2
54040 .*---------------------------------------------------------------------*
54043 <TC- BER decoding REAL, decimal form NR3 pretending to be NR2>
54053 IMPORTS; -- nothing
54063 external function dec_BER_PDU(in octetstring os, out BERPDU pdu)
54064 with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " }
54066 // pi: 31415926.E-7
54067 const octetstring der_encoded := '090D0233313431353932362E452D37'O;
54068 const BERPDU myValue := 3.1415926;
54072 var BERPDU der_decoded, cer_decoded;
54074 dec_BER_PDU(der_encoded, der_decoded);
54075 if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);}
54079 Dynamic test case error: While BER-decoding type '@Temp.BERPDU': While decoding REAL type: This decimal encoding does not conform to NR2 form.
54085 .*---------------------------------------------------------------------*
54086 :h3. BER decoding REAL, reserved decimal form 0x20
54087 .*---------------------------------------------------------------------*
54090 <TC- BER decoding REAL, reserved decimal form 0x20>
54100 IMPORTS; -- nothing
54110 external function dec_BER_PDU(in octetstring os, out BERPDU pdu)
54111 with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " }
54113 // pi: 31415926.E-7
54114 const octetstring der_encoded := '090D2033313431353932362E452D37'O;
54115 const BERPDU myValue := 3.1415926;
54119 var BERPDU der_decoded, cer_decoded;
54121 dec_BER_PDU(der_encoded, der_decoded);
54122 if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);}
54126 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).
54133 .*---------------------------------------------------------------------*
54134 :h3. BER decoding REAL, decimal form 0
54135 .*---------------------------------------------------------------------*
54138 <TC- BER decoding REAL, decimal form 0>
54148 IMPORTS; -- nothing
54158 external function dec_BER_PDU(in octetstring os, out BERPDU pdu)
54159 with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " }
54161 // pi: 31415926.E-7
54162 const octetstring der_encoded := '090D0033313431353932362E452D37'O;
54163 const BERPDU myValue := 3.1415926;
54167 var BERPDU der_decoded, cer_decoded;
54169 dec_BER_PDU(der_encoded, der_decoded);
54170 if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);}
54174 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).
54181 .*---------------------------------------------------------------------*
54182 :h3. BER decoding REAL, decimal form 4
54183 .*---------------------------------------------------------------------*
54186 <TC- BER decoding REAL, decimal form 4>
54196 IMPORTS; -- nothing
54206 external function dec_BER_PDU(in octetstring os, out BERPDU pdu)
54207 with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " }
54209 // pi: 31415926.E-7
54210 const octetstring der_encoded := '090D0433313431353932362E452D37'O;
54211 const BERPDU myValue := 3.1415926;
54215 var BERPDU der_decoded, cer_decoded;
54217 dec_BER_PDU(der_encoded, der_decoded);
54218 if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);}
54222 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).
54228 .*---------------------------------------------------------------------*
54229 :h3. Memory leak while BER decoding, test for HO73756
54230 .*---------------------------------------------------------------------*
54233 <TC - Memory leak while BER decoding, test for HO73756>
54236 TempA DEFINITIONS ::=
54239 MY-CLASS-1 ::= CLASS
54241 &TypeField OPTIONAL,
54242 &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL
54247 [TYPE FIELD &TypeField]
54248 [FIXED VALUE TYPE FIELD &fixedTypeValueField]
54251 ASN1-Type1 ::= INTEGER
54253 ASN1-Type2 ::= BOOLEAN
54255 ASN1-Type3 ::= SEQUENCE {f1 INTEGER}
54257 ASN1-Type4 ::= OCTET STRING
54259 myObject-1 MY-CLASS-1 ::=
54261 TYPE FIELD ASN1-Type3
54262 FIXED VALUE TYPE FIELD 999
54265 myObject-2 MY-CLASS-1 ::=
54267 TYPE FIELD ASN1-Type2
54268 FIXED VALUE TYPE FIELD 888
54271 myObject-3 MY-CLASS-1 ::=
54273 TYPE FIELD ASN1-Type4
54274 FIXED VALUE TYPE FIELD 555
54277 MyInformationObjectSet1 MY-CLASS-1 ::=
54279 myObject-1|myObject-2,
54283 MyInformationObjectSet2 MY-CLASS-1 ::=
54285 MyInformationObjectSet1|myObject-3,
54289 BERPDU ::= SEQUENCE
54291 field1 MY-CLASS-1.&TypeField ({MyInformationObjectSet1} {@.field2} ),
54292 field2 MY-CLASS-1.&fixedTypeValueField ({MyInformationObjectSet1})
54297 // Test for memory leak problem in BER decoder: HO73756.
54298 import from TempA all;
54300 external function dec_backtrack(in octetstring stream, out BERPDU outpdu) return integer with { extension "prototype(backtrack) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
54302 type component empty {
54306 <TTCN_TC:PURE_EXEC>
54308 testcase mytc() runs on empty {
54309 dec_backtrack('30093003020108020203E7'O, mypdu)
54310 dec_backtrack('30093003020108020203E7'O, mypdu)
54320 Overall verdict: pass
54326 .*---------------------------------------------------------------------*
54328 .*---------------------------------------------------------------------*
54329 :nl. Requirement specification(s):
54330 :nl.-------------------------------
54332 :li. 8/ETH/RUS-2003:0087 Uen - Requirement Specification for TITAN's encoder/decoder functions