Commit | Line | Data |
---|---|---|
970ed795 EL |
1 | .****************************************************************************** |
2 | .* Copyright (c) 2000-2014 Ericsson Telecom AB | |
3 | .* All rights reserved. This program and the accompanying materials | |
4 | .* are made available under the terms of the Eclipse Public License v1.0 | |
5 | .* which accompanies this distribution, and is available at | |
6 | .* http://www.eclipse.org/legal/epl-v10.html | |
7 | .******************************************************************************/ | |
8 | :text. | |
9 | :lang eng. | |
10 | .* | |
11 | :docname.Test Description | |
12 | :docno.8/152 91-CRL 113 200/3 Uen | |
13 | :rev.A | |
14 | :date.2013-01-17 | |
15 | .* | |
16 | :prep.ETH/XZR Krisztian Pandi | |
17 | :appr.ETH/XZ (Gyula Koos) | |
18 | :checked.ETHGRY | |
19 | .* | |
20 | :title.Test Description - BER coder | |
21 | :contents level=3. | |
22 | .*---------------------------------------------------------------------* | |
23 | :h1.PREREQUISITES AND PREPARATIONS | |
24 | .*---------------------------------------------------------------------* | |
25 | .*---------------------------------------------------------------------* | |
26 | :h2.Scope of the Test Object | |
27 | .*---------------------------------------------------------------------* | |
28 | :xmp tab=1 nokeep. | |
29 | ||
30 | This file is obsolate, don't modify, improve it anymore! | |
31 | ||
32 | This TD contains test cases related to TTCN3 Executor's BER coder function. | |
33 | DON'T YOU DARE TO WRITE AN INSPECTION RECORD ABOUT THIS FILE. | |
34 | ||
35 | :exmp. | |
36 | ||
37 | :p.:us.Revision Information:eus. | |
38 | ||
39 | :xmp nokeep. | |
40 | :us.History:eus. | |
41 | ||
42 | REV DATE PREPARED CHANGE | |
43 | === ========== ======== ====== | |
44 | A 2003-10-31 ETHEKR New document | |
45 | B 2007-03-06 EDMDELI Implicit message encoding | |
46 | C 2007-03-21 EJNOSZA Bugfix in a testcase for implicit msg. enc. | |
47 | D 2008-10-01 EFERKOV Big integers | |
48 | E 2010-01-18 EKRISZA Updated for TITAN R8C | |
49 | F 2011-06-18 EKRISZA Added tests for errors | |
50 | A 2011-12-12 EKRISZA Updated for release | |
51 | A 2012-06-27 EFERKOV Updated for release | |
52 | A 2013-01-17 EKRIPND Updated for release | |
53 | :exmp. | |
54 | ||
55 | .*---------------------------------------------------------------------* | |
56 | :h2.Test Tools | |
57 | .*---------------------------------------------------------------------* | |
58 | :p.:us.Software Tools:eus. | |
59 | :xmp tab=2 nokeep. | |
60 | ||
61 | SAtester | |
62 | ||
63 | :exmp. | |
64 | :np. | |
65 | .*---------------------------------------------------------------------* | |
66 | :h1.REQUIREMENT-BASED TESTS | |
67 | .*---------------------------------------------------------------------* | |
68 | .*---------------------------------------------------------------------* | |
69 | :h2.Testing FIELDLENGTH Attribute | |
70 | .*---------------------------------------------------------------------* | |
71 | .*---------------------------------------------------------------------* | |
72 | :h3. DER + CER encoding of BOOLEAN TRUE | |
73 | .*---------------------------------------------------------------------* | |
74 | :xmp tab=0. | |
75 | ||
76 | <TC - DER + CER encoding of BOOLEAN TRUE > | |
77 | ||
78 | <STATIC:ASN> | |
79 | ||
80 | TempA | |
81 | ||
82 | DEFINITIONS ::= | |
83 | ||
84 | ||
85 | BEGIN | |
86 | BERPDU ::= BOOLEAN | |
87 | END | |
88 | ||
89 | <STATIC> | |
90 | ||
91 | import from TempA all; | |
92 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
93 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
94 | ||
95 | const BERPDU b := true | |
96 | ||
97 | <TTCN_TC:EXEC> | |
98 | ||
99 | if ((enc_DER_PDU(b) == '0101FF'O)and(enc_CER_PDU(b) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);} | |
100 | ||
101 | <RESULT> | |
102 | ||
103 | Overall verdict: pass | |
104 | ||
105 | <END_TC> | |
106 | ||
107 | :exmp. | |
108 | ||
109 | .*---------------------------------------------------------------------* | |
110 | :h3. DER + CER encoding of BOOLEAN FALSE | |
111 | .*---------------------------------------------------------------------* | |
112 | :xmp tab=0. | |
113 | ||
114 | <TC - DER + CER encoding of BOOLEAN FALSE > | |
115 | ||
116 | <STATIC:ASN> | |
117 | ||
118 | TempA | |
119 | ||
120 | DEFINITIONS ::= | |
121 | BEGIN | |
122 | BERPDU ::= BOOLEAN | |
123 | END | |
124 | ||
125 | <STATIC> | |
126 | ||
127 | import from TempA all; | |
128 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
129 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
130 | ||
131 | const BERPDU b := false | |
132 | ||
133 | <TTCN_TC:EXEC> | |
134 | ||
135 | if ((enc_DER_PDU(b) == '010100'O)and(enc_CER_PDU(b) == '010100'O)) {setverdict(pass);} else {setverdict(fail);} | |
136 | ||
137 | <RESULT> | |
138 | ||
139 | Overall verdict: pass | |
140 | ||
141 | <END_TC> | |
142 | ||
143 | :exmp. | |
144 | ||
145 | .*---------------------------------------------------------------------* | |
146 | :h3. DER + CER encoding of BOOLEAN with Context Specific TAG, EXPLICIT | |
147 | .*---------------------------------------------------------------------* | |
148 | :xmp tab=0. | |
149 | ||
150 | <TC - DER + CER encoding of BOOLEAN with Context Specific TAG, EXPLICIT> | |
151 | ||
152 | <STATIC:ASN> | |
153 | ||
154 | TempA | |
155 | ||
156 | DEFINITIONS ::= | |
157 | BEGIN | |
158 | BERPDU ::= [0] EXPLICIT BOOLEAN | |
159 | END | |
160 | ||
161 | <STATIC> | |
162 | ||
163 | import from TempA all; | |
164 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
165 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
166 | ||
167 | const BERPDU b := true | |
168 | ||
169 | <TTCN_TC:EXEC> | |
170 | ||
171 | if ((enc_DER_PDU(b) == 'A0030101FF'O)and(enc_CER_PDU(b) == 'A0800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
172 | ||
173 | <RESULT> | |
174 | ||
175 | Overall verdict: pass | |
176 | ||
177 | <END_TC> | |
178 | ||
179 | :exmp. | |
180 | ||
181 | .*---------------------------------------------------------------------* | |
182 | :h3. DER + CER encoding of BOOLEAN with PRIVATE TAG, EXPLICIT | |
183 | .*---------------------------------------------------------------------* | |
184 | :xmp tab=0. | |
185 | ||
186 | <TC - DER + CER encoding of BOOLEAN with PRIVATE TAG, EXPLICIT> | |
187 | ||
188 | <STATIC:ASN> | |
189 | ||
190 | TempA | |
191 | ||
192 | DEFINITIONS ::= | |
193 | BEGIN | |
194 | BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN | |
195 | END | |
196 | ||
197 | <STATIC> | |
198 | ||
199 | import from TempA all; | |
200 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
201 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
202 | ||
203 | const BERPDU b := true | |
204 | ||
205 | <TTCN_TC:EXEC> | |
206 | ||
207 | if ((enc_DER_PDU(b) == 'E1030101FF'O)and(enc_CER_PDU(b) == 'E1800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
208 | ||
209 | <RESULT> | |
210 | ||
211 | Overall verdict: pass | |
212 | ||
213 | <END_TC> | |
214 | ||
215 | :exmp. | |
216 | ||
217 | .*---------------------------------------------------------------------* | |
218 | :h3. DER + CER encoding of BOOLEAN with APPLICATION TAG, EXPLICIT | |
219 | .*---------------------------------------------------------------------* | |
220 | :xmp tab=0. | |
221 | ||
222 | <TC - DER + CER encoding of BOOLEAN with APPLICATION TAG, EXPLICIT> | |
223 | ||
224 | <STATIC:ASN> | |
225 | ||
226 | TempA | |
227 | ||
228 | DEFINITIONS ::= | |
229 | BEGIN | |
230 | BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN | |
231 | END | |
232 | ||
233 | <STATIC> | |
234 | ||
235 | import from TempA all; | |
236 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
237 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
238 | ||
239 | const BERPDU b := true | |
240 | ||
241 | <TTCN_TC:EXEC> | |
242 | ||
243 | if ((enc_DER_PDU(b) == '62030101FF'O)and(enc_CER_PDU(b) == '62800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
244 | ||
245 | <RESULT> | |
246 | ||
247 | Overall verdict: pass | |
248 | ||
249 | <END_TC> | |
250 | ||
251 | :exmp. | |
252 | ||
253 | .*---------------------------------------------------------------------* | |
254 | :h3. DER + CER encoding of BOOLEAN with Context Specific TAG, IMPLICIT | |
255 | .*---------------------------------------------------------------------* | |
256 | :xmp tab=0. | |
257 | ||
258 | <TC - DER + CER encoding of BOOLEAN with Context Specific TAG, IMPLICIT> | |
259 | ||
260 | <STATIC:ASN> | |
261 | ||
262 | TempA | |
263 | ||
264 | DEFINITIONS ::= | |
265 | BEGIN | |
266 | BERPDU ::= [0] IMPLICIT BOOLEAN | |
267 | END | |
268 | ||
269 | <STATIC> | |
270 | ||
271 | import from TempA all; | |
272 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
273 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
274 | ||
275 | const BERPDU b := false | |
276 | ||
277 | <TTCN_TC:EXEC> | |
278 | ||
279 | if ((enc_DER_PDU(b) == '800100'O)and(enc_CER_PDU(b) == '800100'O)) {setverdict(pass);} else {setverdict(fail);} | |
280 | ||
281 | <RESULT> | |
282 | ||
283 | Overall verdict: pass | |
284 | ||
285 | <END_TC> | |
286 | ||
287 | :exmp. | |
288 | ||
289 | .*---------------------------------------------------------------------* | |
290 | :h3. DER + CER encoding of BOOLEAN with PRIVATE TAG, IMPLICIT | |
291 | .*---------------------------------------------------------------------* | |
292 | :xmp tab=0. | |
293 | ||
294 | <TC - DER + CER encoding of BOOLEAN with PRIVATE TAG, IMPLICIT> | |
295 | ||
296 | <STATIC:ASN> | |
297 | ||
298 | TempA | |
299 | ||
300 | DEFINITIONS ::= | |
301 | BEGIN | |
302 | BERPDU ::= [PRIVATE 1] IMPLICIT BOOLEAN | |
303 | END | |
304 | ||
305 | <STATIC> | |
306 | ||
307 | import from TempA all; | |
308 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
309 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
310 | ||
311 | const BERPDU b := false | |
312 | ||
313 | <TTCN_TC:EXEC> | |
314 | ||
315 | if ((enc_DER_PDU(b) == 'C10100'O)and(enc_CER_PDU(b) == 'C10100'O)) {setverdict(pass);} else {setverdict(fail);} | |
316 | ||
317 | <RESULT> | |
318 | ||
319 | Overall verdict: pass | |
320 | ||
321 | <END_TC> | |
322 | ||
323 | :exmp. | |
324 | ||
325 | .*---------------------------------------------------------------------* | |
326 | :h3. DER + CER encoding of BOOLEAN with APPLICATION TAG, IMPLICIT | |
327 | .*---------------------------------------------------------------------* | |
328 | :xmp tab=0. | |
329 | ||
330 | <TC - DER + CER encoding of BOOLEAN with APPLICATION TAG, IMPLICIT> | |
331 | ||
332 | <STATIC:ASN> | |
333 | ||
334 | TempA | |
335 | ||
336 | DEFINITIONS ::= | |
337 | BEGIN | |
338 | BERPDU ::= [APPLICATION 2] IMPLICIT BOOLEAN | |
339 | END | |
340 | ||
341 | <STATIC> | |
342 | ||
343 | import from TempA all; | |
344 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
345 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
346 | ||
347 | const BERPDU b := true | |
348 | ||
349 | <TTCN_TC:EXEC> | |
350 | ||
351 | if ((enc_DER_PDU(b) == '4201FF'O)and(enc_CER_PDU(b) == '4201FF'O)) {setverdict(pass);} else {setverdict(fail);} | |
352 | ||
353 | <RESULT> | |
354 | ||
355 | Overall verdict: pass | |
356 | ||
357 | <END_TC> | |
358 | ||
359 | :exmp. | |
360 | ||
361 | .*---------------------------------------------------------------------* | |
362 | :h3. DECODING BOOLEAN, CER+DER | |
363 | .*---------------------------------------------------------------------* | |
364 | :xmp tab=0. | |
365 | ||
366 | <TC - DECODING BOOLEAN, CER+DER> | |
367 | ||
368 | <STATIC:ASN> | |
369 | ||
370 | TempA | |
371 | ||
372 | DEFINITIONS ::= | |
373 | BEGIN | |
374 | BERPDU ::= BOOLEAN | |
375 | ||
376 | myBooleanValue BERPDU ::= TRUE | |
377 | ||
378 | END | |
379 | ||
380 | <STATIC> | |
381 | ||
382 | import from TempA all; | |
383 | ||
384 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
385 | ||
386 | ||
387 | <TTCN_TC:EXEC> | |
388 | ||
389 | if (dec_BER_PDU('0101FF'O) == myBooleanValue) | |
390 | ||
391 | ||
392 | {setverdict(pass);} else {setverdict(fail);} | |
393 | ||
394 | ||
395 | <RESULT> | |
396 | ||
397 | Overall verdict: pass | |
398 | ||
399 | <END_TC> | |
400 | ||
401 | :exmp. | |
402 | ||
403 | .*---------------------------------------------------------------------* | |
404 | :h3. DECODING BOOLEAN, CER+DER | |
405 | .*---------------------------------------------------------------------* | |
406 | :xmp tab=0. | |
407 | ||
408 | <TC - DECODING BOOLEAN, CER+DER> | |
409 | ||
410 | <STATIC:ASN> | |
411 | ||
412 | TempA | |
413 | ||
414 | DEFINITIONS ::= | |
415 | BEGIN | |
416 | BERPDU ::= BOOLEAN | |
417 | ||
418 | myBooleanValue BERPDU ::= FALSE | |
419 | ||
420 | END | |
421 | ||
422 | <STATIC> | |
423 | ||
424 | import from TempA all; | |
425 | ||
426 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
427 | ||
428 | ||
429 | <TTCN_TC:EXEC> | |
430 | ||
431 | if (dec_BER_PDU('010100'O) == myBooleanValue) | |
432 | ||
433 | ||
434 | {setverdict(pass);} else {setverdict(fail);} | |
435 | ||
436 | ||
437 | <RESULT> | |
438 | ||
439 | Overall verdict: pass | |
440 | ||
441 | <END_TC> | |
442 | ||
443 | :exmp. | |
444 | ||
445 | .*---------------------------------------------------------------------* | |
446 | :h3. DECODING BOOLEAN, (LENGTH OF LENGTH = 1) | |
447 | .*---------------------------------------------------------------------* | |
448 | :xmp tab=0. | |
449 | ||
450 | <TC - DECODING BOOLEAN, (LENGTH OF LENGTH = 1)> | |
451 | ||
452 | <STATIC:ASN> | |
453 | ||
454 | TempA | |
455 | ||
456 | DEFINITIONS ::= | |
457 | BEGIN | |
458 | BERPDU ::= BOOLEAN | |
459 | ||
460 | myBooleanValue BERPDU ::= TRUE | |
461 | ||
462 | END | |
463 | ||
464 | <STATIC> | |
465 | ||
466 | import from TempA all; | |
467 | ||
468 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
469 | ||
470 | ||
471 | <TTCN_TC:EXEC> | |
472 | ||
473 | if (dec_BER_PDU('05810101'O) == myBooleanValue) | |
474 | ||
475 | ||
476 | {setverdict(pass);} else {setverdict(fail);} | |
477 | ||
478 | ||
479 | <RESULT> | |
480 | ||
481 | Overall verdict: pass | |
482 | ||
483 | <END_TC> | |
484 | ||
485 | :exmp. | |
486 | ||
487 | .*---------------------------------------------------------------------* | |
488 | :h3. DECODING BOOELAN, (LENGTH OF LENGTH = 2) | |
489 | .*---------------------------------------------------------------------* | |
490 | :xmp tab=0. | |
491 | ||
492 | <TC - DECODING BOOELAN, (LENGTH OF LENGTH = 2)> | |
493 | ||
494 | <STATIC:ASN> | |
495 | ||
496 | TempA | |
497 | ||
498 | DEFINITIONS ::= | |
499 | BEGIN | |
500 | BERPDU ::= BOOLEAN | |
501 | ||
502 | myBooleanValue BERPDU ::= FALSE | |
503 | ||
504 | END | |
505 | ||
506 | <STATIC> | |
507 | ||
508 | import from TempA all; | |
509 | ||
510 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
511 | ||
512 | ||
513 | <TTCN_TC:EXEC> | |
514 | ||
515 | if (dec_BER_PDU('0582000100'O) == myBooleanValue) | |
516 | ||
517 | ||
518 | {setverdict(pass);} else {setverdict(fail);} | |
519 | ||
520 | ||
521 | <RESULT> | |
522 | ||
523 | Overall verdict: pass | |
524 | ||
525 | <END_TC> | |
526 | ||
527 | :exmp. | |
528 | ||
529 | .*---------------------------------------------------------------------* | |
530 | :h3. DECODING [0] EXPLICIT BOOLEAN , DER, Short form - short form | |
531 | .*---------------------------------------------------------------------* | |
532 | :xmp tab=0. | |
533 | ||
534 | <TC - DECODING [0] EXPLICIT BOOLEAN , DER, Short form - short form> | |
535 | ||
536 | <STATIC:ASN> | |
537 | ||
538 | TempA | |
539 | ||
540 | DEFINITIONS ::= | |
541 | BEGIN | |
542 | BERPDU ::= [0] EXPLICIT BOOLEAN | |
543 | ||
544 | myBooleanValue BERPDU ::= TRUE | |
545 | ||
546 | END | |
547 | ||
548 | <STATIC> | |
549 | ||
550 | import from TempA all; | |
551 | ||
552 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
553 | ||
554 | ||
555 | <TTCN_TC:EXEC> | |
556 | ||
557 | if (dec_BER_PDU('A0030101FF'O) == myBooleanValue) | |
558 | ||
559 | ||
560 | {setverdict(pass);} else {setverdict(fail);} | |
561 | ||
562 | ||
563 | <RESULT> | |
564 | ||
565 | Overall verdict: pass | |
566 | ||
567 | <END_TC> | |
568 | ||
569 | :exmp. | |
570 | ||
571 | .*---------------------------------------------------------------------* | |
572 | :h3. DECODING [0] EXPLICIT BOOLEAN, CER | |
573 | .*---------------------------------------------------------------------* | |
574 | :xmp tab=0. | |
575 | ||
576 | <TC - DECODING [0] EXPLICIT BOOLEAN, CER> | |
577 | ||
578 | <STATIC:ASN> | |
579 | ||
580 | TempA | |
581 | ||
582 | DEFINITIONS ::= | |
583 | BEGIN | |
584 | BERPDU ::= [0] EXPLICIT BOOLEAN | |
585 | ||
586 | myBooleanValue BERPDU ::= TRUE | |
587 | ||
588 | END | |
589 | ||
590 | <STATIC> | |
591 | ||
592 | import from TempA all; | |
593 | ||
594 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
595 | ||
596 | ||
597 | <TTCN_TC:EXEC> | |
598 | ||
599 | if (dec_BER_PDU('A0800101FF0000'O) == myBooleanValue) | |
600 | ||
601 | ||
602 | {setverdict(pass);} else {setverdict(fail);} | |
603 | ||
604 | ||
605 | <RESULT> | |
606 | ||
607 | Overall verdict: pass | |
608 | ||
609 | <END_TC> | |
610 | ||
611 | :exmp. | |
612 | ||
613 | .*---------------------------------------------------------------------* | |
614 | :h3. DECODING [0] EXPLICIT BOOLEAN, Long form - short form | |
615 | .*---------------------------------------------------------------------* | |
616 | :xmp tab=0. | |
617 | ||
618 | <TC - DECODING [0] EXPLICIT BOOLEAN, Long form - short form> | |
619 | ||
620 | <STATIC:ASN> | |
621 | ||
622 | TempA | |
623 | ||
624 | DEFINITIONS ::= | |
625 | BEGIN | |
626 | BERPDU ::= [0] EXPLICIT BOOLEAN | |
627 | ||
628 | myBooleanValue BERPDU ::= TRUE | |
629 | ||
630 | END | |
631 | ||
632 | <STATIC> | |
633 | ||
634 | import from TempA all; | |
635 | ||
636 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
637 | ||
638 | ||
639 | <TTCN_TC:EXEC> | |
640 | ||
641 | if (dec_BER_PDU('A081030101FF'O) == myBooleanValue) | |
642 | ||
643 | ||
644 | {setverdict(pass);} else {setverdict(fail);} | |
645 | ||
646 | ||
647 | <RESULT> | |
648 | ||
649 | Overall verdict: pass | |
650 | ||
651 | <END_TC> | |
652 | ||
653 | :exmp. | |
654 | ||
655 | .*---------------------------------------------------------------------* | |
656 | :h3. DECODING [0] EXPLICIT BOOLEAN, Long form Long form | |
657 | .*---------------------------------------------------------------------* | |
658 | :xmp tab=0. | |
659 | ||
660 | <TC - DECODING [0] EXPLICIT BOOLEAN, Long form Long form> | |
661 | ||
662 | <STATIC:ASN> | |
663 | ||
664 | TempA | |
665 | ||
666 | DEFINITIONS ::= | |
667 | BEGIN | |
668 | BERPDU ::= [0] EXPLICIT BOOLEAN | |
669 | ||
670 | myBooleanValue BERPDU ::= TRUE | |
671 | ||
672 | END | |
673 | ||
674 | <STATIC> | |
675 | ||
676 | import from TempA all; | |
677 | ||
678 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
679 | ||
680 | ||
681 | <TTCN_TC:EXEC> | |
682 | ||
683 | if (dec_BER_PDU('A0810401810199'O) == myBooleanValue) | |
684 | ||
685 | ||
686 | {setverdict(pass);} else {setverdict(fail);} | |
687 | ||
688 | ||
689 | <RESULT> | |
690 | ||
691 | Overall verdict: pass | |
692 | ||
693 | <END_TC> | |
694 | ||
695 | :exmp. | |
696 | ||
697 | .*---------------------------------------------------------------------* | |
698 | :h3. DECODING [PRIVATE 1] EXPLICIT BOOLEAN , DER, Short form - short form | |
699 | .*---------------------------------------------------------------------* | |
700 | :xmp tab=0. | |
701 | ||
702 | <TC - DECODING [PRIVATE 1] EXPLICIT BOOLEAN , DER, Short form - short form> | |
703 | ||
704 | <STATIC:ASN> | |
705 | ||
706 | TempA | |
707 | ||
708 | DEFINITIONS ::= | |
709 | BEGIN | |
710 | BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN | |
711 | ||
712 | myBooleanValue BERPDU ::= TRUE | |
713 | ||
714 | END | |
715 | ||
716 | <STATIC> | |
717 | ||
718 | import from TempA all; | |
719 | ||
720 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
721 | ||
722 | ||
723 | <TTCN_TC:EXEC> | |
724 | ||
725 | if (dec_BER_PDU('E1030101FF'O) == myBooleanValue) | |
726 | ||
727 | ||
728 | {setverdict(pass);} else {setverdict(fail);} | |
729 | ||
730 | ||
731 | <RESULT> | |
732 | ||
733 | Overall verdict: pass | |
734 | ||
735 | <END_TC> | |
736 | ||
737 | :exmp. | |
738 | ||
739 | .*---------------------------------------------------------------------* | |
740 | :h3. DECODING [PRIVATE 1] EXPLICIT BOOLEAN, CER | |
741 | .*---------------------------------------------------------------------* | |
742 | :xmp tab=0. | |
743 | ||
744 | <TC - DECODING [PRIVATE 1] EXPLICIT BOOLEAN, CER> | |
745 | ||
746 | <STATIC:ASN> | |
747 | ||
748 | TempA | |
749 | ||
750 | DEFINITIONS ::= | |
751 | BEGIN | |
752 | BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN | |
753 | ||
754 | myBooleanValue BERPDU ::= TRUE | |
755 | ||
756 | END | |
757 | ||
758 | <STATIC> | |
759 | ||
760 | import from TempA all; | |
761 | ||
762 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
763 | ||
764 | ||
765 | <TTCN_TC:EXEC> | |
766 | ||
767 | if (dec_BER_PDU('E1800101FF0000'O) == myBooleanValue) | |
768 | ||
769 | ||
770 | {setverdict(pass);} else {setverdict(fail);} | |
771 | ||
772 | ||
773 | <RESULT> | |
774 | ||
775 | Overall verdict: pass | |
776 | ||
777 | <END_TC> | |
778 | ||
779 | :exmp. | |
780 | ||
781 | .*---------------------------------------------------------------------* | |
782 | :h3. DECODING [PRIVATE 1] EXPLICIT BOOLEAN, Long form - short form | |
783 | .*---------------------------------------------------------------------* | |
784 | :xmp tab=0. | |
785 | ||
786 | <TC - DECODING [PRIVATE 1] EXPLICIT BOOLEAN, Long form - short form> | |
787 | ||
788 | <STATIC:ASN> | |
789 | ||
790 | TempA | |
791 | ||
792 | DEFINITIONS ::= | |
793 | BEGIN | |
794 | BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN | |
795 | ||
796 | myBooleanValue BERPDU ::= TRUE | |
797 | ||
798 | END | |
799 | ||
800 | <STATIC> | |
801 | ||
802 | import from TempA all; | |
803 | ||
804 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
805 | ||
806 | ||
807 | <TTCN_TC:EXEC> | |
808 | ||
809 | if (dec_BER_PDU('E181030101FF'O) == myBooleanValue) | |
810 | ||
811 | ||
812 | {setverdict(pass);} else {setverdict(fail);} | |
813 | ||
814 | ||
815 | <RESULT> | |
816 | ||
817 | Overall verdict: pass | |
818 | ||
819 | <END_TC> | |
820 | ||
821 | :exmp. | |
822 | ||
823 | .*---------------------------------------------------------------------* | |
824 | :h3. DECODING [PRIVATE 1] EXPLICIT BOOLEAN, Long form Long form | |
825 | .*---------------------------------------------------------------------* | |
826 | :xmp tab=0. | |
827 | ||
828 | <TC - DECODING [PRIVATE 1] EXPLICIT BOOLEAN, Long form Long form> | |
829 | ||
830 | <STATIC:ASN> | |
831 | ||
832 | TempA | |
833 | ||
834 | DEFINITIONS ::= | |
835 | BEGIN | |
836 | BERPDU ::= [PRIVATE 1] EXPLICIT BOOLEAN | |
837 | ||
838 | myBooleanValue BERPDU ::= TRUE | |
839 | ||
840 | END | |
841 | ||
842 | <STATIC> | |
843 | ||
844 | import from TempA all; | |
845 | ||
846 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
847 | ||
848 | ||
849 | <TTCN_TC:EXEC> | |
850 | ||
851 | if (dec_BER_PDU('E1810401810199'O) == myBooleanValue) | |
852 | ||
853 | ||
854 | {setverdict(pass);} else {setverdict(fail);} | |
855 | ||
856 | ||
857 | <RESULT> | |
858 | ||
859 | Overall verdict: pass | |
860 | ||
861 | <END_TC> | |
862 | ||
863 | :exmp. | |
864 | ||
865 | .*---------------------------------------------------------------------* | |
866 | :h3. DECODING [APPLICATION 2] EXPLICIT BOOLEAN , DER, Short form - short form | |
867 | .*---------------------------------------------------------------------* | |
868 | :xmp tab=0. | |
869 | ||
870 | <TC - DECODING [APPLICATION 2] EXPLICIT BOOLEAN , DER, Short form - short form> | |
871 | ||
872 | <STATIC:ASN> | |
873 | ||
874 | TempA | |
875 | ||
876 | DEFINITIONS ::= | |
877 | BEGIN | |
878 | BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN | |
879 | ||
880 | myBooleanValue BERPDU ::= TRUE | |
881 | ||
882 | END | |
883 | ||
884 | <STATIC> | |
885 | ||
886 | import from TempA all; | |
887 | ||
888 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
889 | ||
890 | ||
891 | <TTCN_TC:EXEC> | |
892 | ||
893 | if (dec_BER_PDU('62030101FF'O) == myBooleanValue) | |
894 | ||
895 | ||
896 | {setverdict(pass);} else {setverdict(fail);} | |
897 | ||
898 | ||
899 | <RESULT> | |
900 | ||
901 | Overall verdict: pass | |
902 | ||
903 | <END_TC> | |
904 | ||
905 | :exmp. | |
906 | ||
907 | .*---------------------------------------------------------------------* | |
908 | :h3. DECODING [APPLICATION 2] EXPLICIT BOOLEAN, CER | |
909 | .*---------------------------------------------------------------------* | |
910 | :xmp tab=0. | |
911 | ||
912 | <TC - DECODING [APPLICATION 2] EXPLICIT BOOLEAN, CER> | |
913 | ||
914 | <STATIC:ASN> | |
915 | ||
916 | TempA | |
917 | ||
918 | DEFINITIONS ::= | |
919 | BEGIN | |
920 | BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN | |
921 | ||
922 | myBooleanValue BERPDU ::= TRUE | |
923 | ||
924 | END | |
925 | ||
926 | <STATIC> | |
927 | ||
928 | import from TempA all; | |
929 | ||
930 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
931 | ||
932 | ||
933 | <TTCN_TC:EXEC> | |
934 | ||
935 | if (dec_BER_PDU('62800101FF0000'O) == myBooleanValue) | |
936 | ||
937 | ||
938 | {setverdict(pass);} else {setverdict(fail);} | |
939 | ||
940 | ||
941 | <RESULT> | |
942 | ||
943 | Overall verdict: pass | |
944 | ||
945 | <END_TC> | |
946 | ||
947 | :exmp. | |
948 | ||
949 | .*---------------------------------------------------------------------* | |
950 | :h3. DECODING [APPLICATION 2] EXPLICIT BOOLEAN, Long form - short form | |
951 | .*---------------------------------------------------------------------* | |
952 | :xmp tab=0. | |
953 | ||
954 | <TC - DECODING [APPLICATION 2] EXPLICIT BOOLEAN, Long form - short form> | |
955 | ||
956 | <STATIC:ASN> | |
957 | ||
958 | TempA | |
959 | ||
960 | DEFINITIONS ::= | |
961 | BEGIN | |
962 | BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN | |
963 | ||
964 | myBooleanValue BERPDU ::= TRUE | |
965 | ||
966 | END | |
967 | ||
968 | <STATIC> | |
969 | ||
970 | import from TempA all; | |
971 | ||
972 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
973 | ||
974 | ||
975 | <TTCN_TC:EXEC> | |
976 | ||
977 | if (dec_BER_PDU('6281030101FF'O) == myBooleanValue) | |
978 | ||
979 | ||
980 | {setverdict(pass);} else {setverdict(fail);} | |
981 | ||
982 | ||
983 | <RESULT> | |
984 | ||
985 | Overall verdict: pass | |
986 | ||
987 | <END_TC> | |
988 | ||
989 | :exmp. | |
990 | ||
991 | .*---------------------------------------------------------------------* | |
992 | :h3. DECODING [APPLICATION 2] EXPLICIT BOOLEAN, Long form Long form | |
993 | .*---------------------------------------------------------------------* | |
994 | :xmp tab=0. | |
995 | ||
996 | <TC - DECODING [APPLICATION 2] EXPLICIT BOOLEAN, Long form Long form> | |
997 | ||
998 | <STATIC:ASN> | |
999 | ||
1000 | TempA | |
1001 | ||
1002 | DEFINITIONS ::= | |
1003 | BEGIN | |
1004 | BERPDU ::= [APPLICATION 2] EXPLICIT BOOLEAN | |
1005 | ||
1006 | myBooleanValue BERPDU ::= TRUE | |
1007 | ||
1008 | END | |
1009 | ||
1010 | <STATIC> | |
1011 | ||
1012 | import from TempA all; | |
1013 | ||
1014 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
1015 | ||
1016 | ||
1017 | <TTCN_TC:EXEC> | |
1018 | ||
1019 | if (dec_BER_PDU('62810401810199'O) == myBooleanValue) | |
1020 | ||
1021 | ||
1022 | {setverdict(pass);} else {setverdict(fail);} | |
1023 | ||
1024 | ||
1025 | <RESULT> | |
1026 | ||
1027 | Overall verdict: pass | |
1028 | ||
1029 | <END_TC> | |
1030 | ||
1031 | :exmp. | |
1032 | ||
1033 | .*---------------------------------------------------------------------* | |
1034 | :h3. DECODING [0] IMPLICIT BOOLEAN ,Short form CER,DER | |
1035 | .*---------------------------------------------------------------------* | |
1036 | :xmp tab=0. | |
1037 | ||
1038 | <TC - DECODING [0] IMPLICIT BOOLEAN ,Short form CER,DER> | |
1039 | ||
1040 | <STATIC:ASN> | |
1041 | ||
1042 | TempA | |
1043 | ||
1044 | DEFINITIONS ::= | |
1045 | BEGIN | |
1046 | BERPDU ::= [0] IMPLICIT BOOLEAN | |
1047 | ||
1048 | myBooleanValue BERPDU ::= TRUE | |
1049 | ||
1050 | END | |
1051 | ||
1052 | <STATIC> | |
1053 | ||
1054 | import from TempA all; | |
1055 | ||
1056 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
1057 | ||
1058 | ||
1059 | <TTCN_TC:EXEC> | |
1060 | ||
1061 | if (dec_BER_PDU('8001FF'O) == myBooleanValue) | |
1062 | ||
1063 | ||
1064 | {setverdict(pass);} else {setverdict(fail);} | |
1065 | ||
1066 | ||
1067 | <RESULT> | |
1068 | ||
1069 | Overall verdict: pass | |
1070 | ||
1071 | <END_TC> | |
1072 | ||
1073 | :exmp. | |
1074 | ||
1075 | .*---------------------------------------------------------------------* | |
1076 | :h3. DECODING [0] IMPLICIT BOOLEAN,Long form | |
1077 | .*---------------------------------------------------------------------* | |
1078 | :xmp tab=0. | |
1079 | ||
1080 | <TC - DECODING [0] IMPLICIT BOOLEAN,Long form> | |
1081 | ||
1082 | <STATIC:ASN> | |
1083 | ||
1084 | TempA | |
1085 | ||
1086 | DEFINITIONS ::= | |
1087 | BEGIN | |
1088 | BERPDU ::= [0] IMPLICIT BOOLEAN | |
1089 | ||
1090 | myBooleanValue BERPDU ::= TRUE | |
1091 | ||
1092 | END | |
1093 | ||
1094 | <STATIC> | |
1095 | ||
1096 | import from TempA all; | |
1097 | ||
1098 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
1099 | ||
1100 | ||
1101 | <TTCN_TC:EXEC> | |
1102 | ||
1103 | if (dec_BER_PDU('80810133'O) == myBooleanValue) | |
1104 | ||
1105 | ||
1106 | {setverdict(pass);} else {setverdict(fail);} | |
1107 | ||
1108 | ||
1109 | <RESULT> | |
1110 | ||
1111 | Overall verdict: pass | |
1112 | ||
1113 | <END_TC> | |
1114 | ||
1115 | :exmp. | |
1116 | ||
1117 | .*---------------------------------------------------------------------* | |
1118 | :h3. DECODING [PRIVATE 1] IMPLICIT BOOLEAN,Short form CER,DER | |
1119 | .*---------------------------------------------------------------------* | |
1120 | :xmp tab=0. | |
1121 | ||
1122 | <TC - DECODING [PRIVATE 1] IMPLICIT BOOLEAN,Short form CER,DER> | |
1123 | ||
1124 | <STATIC:ASN> | |
1125 | ||
1126 | TempA | |
1127 | ||
1128 | DEFINITIONS ::= | |
1129 | BEGIN | |
1130 | BERPDU ::= [PRIVATE 1] IMPLICIT BOOLEAN | |
1131 | ||
1132 | myBooleanValue BERPDU ::= FALSE | |
1133 | ||
1134 | END | |
1135 | ||
1136 | <STATIC> | |
1137 | ||
1138 | import from TempA all; | |
1139 | ||
1140 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
1141 | ||
1142 | ||
1143 | <TTCN_TC:EXEC> | |
1144 | ||
1145 | if (dec_BER_PDU('C10100'O) == myBooleanValue) | |
1146 | ||
1147 | ||
1148 | {setverdict(pass);} else {setverdict(fail);} | |
1149 | ||
1150 | ||
1151 | <RESULT> | |
1152 | ||
1153 | Overall verdict: pass | |
1154 | ||
1155 | <END_TC> | |
1156 | ||
1157 | :exmp. | |
1158 | ||
1159 | .*---------------------------------------------------------------------* | |
1160 | :h3. DECODING [PRIVATE 1] IMPLICIT BOOLEAN,Long form | |
1161 | .*---------------------------------------------------------------------* | |
1162 | :xmp tab=0. | |
1163 | ||
1164 | <TC - DECODING [PRIVATE 1] IMPLICIT BOOLEAN,Long form> | |
1165 | ||
1166 | <STATIC:ASN> | |
1167 | ||
1168 | TempA | |
1169 | ||
1170 | DEFINITIONS ::= | |
1171 | BEGIN | |
1172 | BERPDU ::= [PRIVATE 1] IMPLICIT BOOLEAN | |
1173 | ||
1174 | myBooleanValue BERPDU ::= TRUE | |
1175 | ||
1176 | END | |
1177 | ||
1178 | <STATIC> | |
1179 | ||
1180 | import from TempA all; | |
1181 | ||
1182 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
1183 | ||
1184 | ||
1185 | <TTCN_TC:EXEC> | |
1186 | ||
1187 | if (dec_BER_PDU('C1810105'O) == myBooleanValue) | |
1188 | ||
1189 | ||
1190 | {setverdict(pass);} else {setverdict(fail);} | |
1191 | ||
1192 | ||
1193 | <RESULT> | |
1194 | ||
1195 | Overall verdict: pass | |
1196 | ||
1197 | <END_TC> | |
1198 | ||
1199 | :exmp. | |
1200 | ||
1201 | .*---------------------------------------------------------------------* | |
1202 | :h3. DECODING [APPLICATION 2] IMPLICIT BOOLEAN,Short form CER,DER | |
1203 | .*---------------------------------------------------------------------* | |
1204 | :xmp tab=0. | |
1205 | ||
1206 | <TC - DECODING [APPLICATION 2] IMPLICIT BOOLEAN,Short form CER,DER> | |
1207 | ||
1208 | <STATIC:ASN> | |
1209 | ||
1210 | TempA | |
1211 | ||
1212 | DEFINITIONS ::= | |
1213 | BEGIN | |
1214 | BERPDU ::= [APPLICATION 2] IMPLICIT BOOLEAN | |
1215 | ||
1216 | myBooleanValue BERPDU ::= FALSE | |
1217 | ||
1218 | END | |
1219 | ||
1220 | <STATIC> | |
1221 | ||
1222 | import from TempA all; | |
1223 | ||
1224 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
1225 | ||
1226 | ||
1227 | <TTCN_TC:EXEC> | |
1228 | ||
1229 | if (dec_BER_PDU('420100'O) == myBooleanValue) | |
1230 | ||
1231 | ||
1232 | {setverdict(pass);} else {setverdict(fail);} | |
1233 | ||
1234 | ||
1235 | <RESULT> | |
1236 | ||
1237 | Overall verdict: pass | |
1238 | ||
1239 | <END_TC> | |
1240 | ||
1241 | :exmp. | |
1242 | ||
1243 | .*---------------------------------------------------------------------* | |
1244 | :h3. DECODING [APPLICATION 2] IMPLICIT BOOLEAN,Long form | |
1245 | .*---------------------------------------------------------------------* | |
1246 | :xmp tab=0. | |
1247 | ||
1248 | <TC - DECODING [APPLICATION 2] IMPLICIT BOOLEAN,Long form> | |
1249 | ||
1250 | <STATIC:ASN> | |
1251 | ||
1252 | TempA | |
1253 | ||
1254 | DEFINITIONS ::= | |
1255 | BEGIN | |
1256 | BERPDU ::= [APPLICATION 2] IMPLICIT BOOLEAN | |
1257 | ||
1258 | myBooleanValue BERPDU ::= TRUE | |
1259 | ||
1260 | END | |
1261 | ||
1262 | <STATIC> | |
1263 | ||
1264 | import from TempA all; | |
1265 | ||
1266 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
1267 | ||
1268 | ||
1269 | <TTCN_TC:EXEC> | |
1270 | ||
1271 | if (dec_BER_PDU('42810188'O) == myBooleanValue) | |
1272 | ||
1273 | ||
1274 | {setverdict(pass);} else {setverdict(fail);} | |
1275 | ||
1276 | ||
1277 | <RESULT> | |
1278 | ||
1279 | Overall verdict: pass | |
1280 | ||
1281 | <END_TC> | |
1282 | ||
1283 | :exmp. | |
1284 | ||
1285 | .*---------------------------------------------------------------------* | |
1286 | :h3. DER + CER encoding of integer (5) | |
1287 | .*---------------------------------------------------------------------* | |
1288 | :xmp tab=0. | |
1289 | ||
1290 | <TC - DER + CER encoding of integer (5)> | |
1291 | START OF INTEGER SECTION | |
1292 | ||
1293 | <STATIC:ASN> | |
1294 | ||
1295 | TempA | |
1296 | ||
1297 | DEFINITIONS ::= | |
1298 | BEGIN | |
1299 | BERPDU ::= INTEGER | |
1300 | END | |
1301 | ||
1302 | <STATIC> | |
1303 | ||
1304 | import from TempA all; | |
1305 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1306 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1307 | ||
1308 | const BERPDU b := 5 | |
1309 | ||
1310 | <TTCN_TC:EXEC> | |
1311 | ||
1312 | if ((enc_DER_PDU(b) == '020105'O)and(enc_CER_PDU(b) == '020105'O)) {setverdict(pass);} else {setverdict(fail);} | |
1313 | ||
1314 | <RESULT> | |
1315 | ||
1316 | Overall verdict: pass | |
1317 | ||
1318 | <END_TC> | |
1319 | ||
1320 | :exmp. | |
1321 | ||
1322 | .*---------------------------------------------------------------------* | |
1323 | :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT | |
1324 | .*---------------------------------------------------------------------* | |
1325 | :xmp tab=0. | |
1326 | ||
1327 | <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT> | |
1328 | ||
1329 | <STATIC:ASN> | |
1330 | ||
1331 | TempA | |
1332 | ||
1333 | DEFINITIONS ::= | |
1334 | BEGIN | |
1335 | BERPDU ::= [0] EXPLICIT INTEGER | |
1336 | END | |
1337 | ||
1338 | <STATIC> | |
1339 | ||
1340 | import from TempA all; | |
1341 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1342 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1343 | ||
1344 | const BERPDU b := 5 | |
1345 | ||
1346 | <TTCN_TC:EXEC> | |
1347 | ||
1348 | if ((enc_DER_PDU(b) == 'A003020105'O)and(enc_CER_PDU(b) == 'A0800201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
1349 | ||
1350 | <RESULT> | |
1351 | ||
1352 | Overall verdict: pass | |
1353 | ||
1354 | <END_TC> | |
1355 | ||
1356 | :exmp. | |
1357 | ||
1358 | .*---------------------------------------------------------------------* | |
1359 | :h3. DER + CER encoding of integer (5) with PRIVATE TAG, EXPLICIT | |
1360 | .*---------------------------------------------------------------------* | |
1361 | :xmp tab=0. | |
1362 | ||
1363 | <TC - DER + CER encoding of integer (5) with PRIVATE TAG, EXPLICIT> | |
1364 | ||
1365 | <STATIC:ASN> | |
1366 | ||
1367 | TempA | |
1368 | ||
1369 | DEFINITIONS ::= | |
1370 | BEGIN | |
1371 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
1372 | END | |
1373 | ||
1374 | <STATIC> | |
1375 | ||
1376 | import from TempA all; | |
1377 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1378 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1379 | ||
1380 | const BERPDU b := 5 | |
1381 | ||
1382 | <TTCN_TC:EXEC> | |
1383 | ||
1384 | if ((enc_DER_PDU(b) == 'E103020105'O)and(enc_CER_PDU(b) == 'E1800201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
1385 | ||
1386 | <RESULT> | |
1387 | ||
1388 | Overall verdict: pass | |
1389 | ||
1390 | <END_TC> | |
1391 | ||
1392 | :exmp. | |
1393 | ||
1394 | .*---------------------------------------------------------------------* | |
1395 | :h3. DER + CER encoding of integer (5) with APPLICATION TAG, EXPLICIT | |
1396 | .*---------------------------------------------------------------------* | |
1397 | :xmp tab=0. | |
1398 | ||
1399 | <TC - DER + CER encoding of integer (5) with APPLICATION TAG, EXPLICIT> | |
1400 | ||
1401 | <STATIC:ASN> | |
1402 | ||
1403 | TempA | |
1404 | ||
1405 | DEFINITIONS ::= | |
1406 | BEGIN | |
1407 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
1408 | END | |
1409 | ||
1410 | <STATIC> | |
1411 | ||
1412 | import from TempA all; | |
1413 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1414 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1415 | ||
1416 | const BERPDU b := 5 | |
1417 | ||
1418 | <TTCN_TC:EXEC> | |
1419 | ||
1420 | if ((enc_DER_PDU(b) == '6203020105'O)and(enc_CER_PDU(b) == '62800201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
1421 | ||
1422 | <RESULT> | |
1423 | ||
1424 | Overall verdict: pass | |
1425 | ||
1426 | <END_TC> | |
1427 | ||
1428 | :exmp. | |
1429 | ||
1430 | .*---------------------------------------------------------------------* | |
1431 | :h3. DER + CER encoding of integer (5) with Context Specific TAG, IMPLICIT | |
1432 | .*---------------------------------------------------------------------* | |
1433 | :xmp tab=0. | |
1434 | ||
1435 | <TC - DER + CER encoding of integer (5) with Context Specific TAG, IMPLICIT> | |
1436 | ||
1437 | <STATIC:ASN> | |
1438 | ||
1439 | TempA | |
1440 | ||
1441 | DEFINITIONS ::= | |
1442 | BEGIN | |
1443 | BERPDU ::= [0] IMPLICIT INTEGER | |
1444 | END | |
1445 | ||
1446 | <STATIC> | |
1447 | ||
1448 | import from TempA all; | |
1449 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1450 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1451 | ||
1452 | const BERPDU b := 5 | |
1453 | ||
1454 | <TTCN_TC:EXEC> | |
1455 | ||
1456 | if ((enc_DER_PDU(b) == '800105'O)and(enc_CER_PDU(b) == '800105'O)) {setverdict(pass);} else {setverdict(fail);} | |
1457 | ||
1458 | <RESULT> | |
1459 | ||
1460 | Overall verdict: pass | |
1461 | ||
1462 | <END_TC> | |
1463 | ||
1464 | :exmp. | |
1465 | ||
1466 | .*---------------------------------------------------------------------* | |
1467 | :h3. DER + CER encoding of integer (5) with PRIVATE TAG, IMPLICIT | |
1468 | .*---------------------------------------------------------------------* | |
1469 | :xmp tab=0. | |
1470 | ||
1471 | <TC - DER + CER encoding of integer (5) with PRIVATE TAG, IMPLICIT> | |
1472 | ||
1473 | <STATIC:ASN> | |
1474 | ||
1475 | TempA | |
1476 | ||
1477 | DEFINITIONS ::= | |
1478 | BEGIN | |
1479 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
1480 | END | |
1481 | ||
1482 | <STATIC> | |
1483 | ||
1484 | import from TempA all; | |
1485 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1486 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1487 | ||
1488 | const BERPDU b := 5 | |
1489 | ||
1490 | <TTCN_TC:EXEC> | |
1491 | ||
1492 | if ((enc_DER_PDU(b) == 'C10105'O)and(enc_CER_PDU(b) == 'C10105'O)) {setverdict(pass);} else {setverdict(fail);} | |
1493 | ||
1494 | <RESULT> | |
1495 | ||
1496 | Overall verdict: pass | |
1497 | ||
1498 | <END_TC> | |
1499 | ||
1500 | :exmp. | |
1501 | ||
1502 | .*---------------------------------------------------------------------* | |
1503 | :h3. DER + CER encoding of integer (5) with APPLICATION TAG, IMPLICIT | |
1504 | .*---------------------------------------------------------------------* | |
1505 | :xmp tab=0. | |
1506 | ||
1507 | <TC - DER + CER encoding of integer (5) with APPLICATION TAG, IMPLICIT> | |
1508 | ||
1509 | <STATIC:ASN> | |
1510 | ||
1511 | TempA | |
1512 | ||
1513 | DEFINITIONS ::= | |
1514 | BEGIN | |
1515 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
1516 | END | |
1517 | ||
1518 | <STATIC> | |
1519 | ||
1520 | import from TempA all; | |
1521 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1522 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1523 | ||
1524 | const BERPDU b := 5 | |
1525 | ||
1526 | <TTCN_TC:EXEC> | |
1527 | ||
1528 | if ((enc_DER_PDU(b) == '420105'O)and(enc_CER_PDU(b) == '420105'O)) {setverdict(pass);} else {setverdict(fail);} | |
1529 | ||
1530 | <RESULT> | |
1531 | ||
1532 | Overall verdict: pass | |
1533 | ||
1534 | <END_TC> | |
1535 | ||
1536 | :exmp. | |
1537 | ||
1538 | .*---------------------------------------------------------------------* | |
1539 | :h3. DER + CER encoding of integer (0) | |
1540 | .*---------------------------------------------------------------------* | |
1541 | :xmp tab=0. | |
1542 | ||
1543 | <TC - DER + CER encoding of integer (0) > | |
1544 | ||
1545 | <STATIC:ASN> | |
1546 | ||
1547 | TempA | |
1548 | ||
1549 | DEFINITIONS ::= | |
1550 | BEGIN | |
1551 | BERPDU ::= INTEGER | |
1552 | END | |
1553 | ||
1554 | <STATIC> | |
1555 | ||
1556 | import from TempA all; | |
1557 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1558 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1559 | ||
1560 | const BERPDU b := 0 | |
1561 | ||
1562 | <TTCN_TC:EXEC> | |
1563 | ||
1564 | if ((enc_DER_PDU(b) == '020100'O)and(enc_CER_PDU(b) == '020100'O)) {setverdict(pass);} else {setverdict(fail);} | |
1565 | ||
1566 | <RESULT> | |
1567 | ||
1568 | Overall verdict: pass | |
1569 | ||
1570 | <END_TC> | |
1571 | ||
1572 | :exmp. | |
1573 | ||
1574 | .*---------------------------------------------------------------------* | |
1575 | :h3. DER + CER encoding of integer (0) with Context Specific TAG, EXPLICIT | |
1576 | .*---------------------------------------------------------------------* | |
1577 | :xmp tab=0. | |
1578 | ||
1579 | <TC - DER + CER encoding of integer (0) with Context Specific TAG, EXPLICIT> | |
1580 | ||
1581 | <STATIC:ASN> | |
1582 | ||
1583 | TempA | |
1584 | ||
1585 | DEFINITIONS ::= | |
1586 | BEGIN | |
1587 | BERPDU ::= [0] EXPLICIT INTEGER | |
1588 | END | |
1589 | ||
1590 | <STATIC> | |
1591 | ||
1592 | import from TempA all; | |
1593 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1594 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1595 | ||
1596 | const BERPDU b := 0 | |
1597 | ||
1598 | <TTCN_TC:EXEC> | |
1599 | ||
1600 | if ((enc_DER_PDU(b) == 'A003020100'O)and(enc_CER_PDU(b) == 'A0800201000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
1601 | ||
1602 | <RESULT> | |
1603 | ||
1604 | Overall verdict: pass | |
1605 | ||
1606 | <END_TC> | |
1607 | ||
1608 | :exmp. | |
1609 | ||
1610 | .*---------------------------------------------------------------------* | |
1611 | :h3. DER + CER encoding of integer (0) with PRIVATE TAG, EXPLICIT | |
1612 | .*---------------------------------------------------------------------* | |
1613 | :xmp tab=0. | |
1614 | ||
1615 | <TC - DER + CER encoding of integer (0) with PRIVATE TAG, EXPLICIT> | |
1616 | ||
1617 | <STATIC:ASN> | |
1618 | ||
1619 | TempA | |
1620 | ||
1621 | DEFINITIONS ::= | |
1622 | BEGIN | |
1623 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
1624 | END | |
1625 | ||
1626 | <STATIC> | |
1627 | ||
1628 | import from TempA all; | |
1629 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1630 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1631 | ||
1632 | const BERPDU b := 0 | |
1633 | ||
1634 | <TTCN_TC:EXEC> | |
1635 | ||
1636 | if ((enc_DER_PDU(b) == 'E103020100'O)and(enc_CER_PDU(b) == 'E1800201000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
1637 | ||
1638 | <RESULT> | |
1639 | ||
1640 | Overall verdict: pass | |
1641 | ||
1642 | <END_TC> | |
1643 | ||
1644 | :exmp. | |
1645 | ||
1646 | .*---------------------------------------------------------------------* | |
1647 | :h3. DER + CER encoding of integer (0) with APPLICATION TAG, EXPLICIT | |
1648 | .*---------------------------------------------------------------------* | |
1649 | :xmp tab=0. | |
1650 | ||
1651 | <TC - DER + CER encoding of integer (0) with APPLICATION TAG, EXPLICIT> | |
1652 | ||
1653 | <STATIC:ASN> | |
1654 | ||
1655 | TempA | |
1656 | ||
1657 | DEFINITIONS ::= | |
1658 | BEGIN | |
1659 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
1660 | END | |
1661 | ||
1662 | <STATIC> | |
1663 | ||
1664 | import from TempA all; | |
1665 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1666 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1667 | ||
1668 | const BERPDU b := 0 | |
1669 | ||
1670 | <TTCN_TC:EXEC> | |
1671 | ||
1672 | if ((enc_DER_PDU(b) == '6203020100'O)and(enc_CER_PDU(b) == '62800201000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
1673 | ||
1674 | <RESULT> | |
1675 | ||
1676 | Overall verdict: pass | |
1677 | ||
1678 | <END_TC> | |
1679 | ||
1680 | :exmp. | |
1681 | ||
1682 | .*---------------------------------------------------------------------* | |
1683 | :h3. DER + CER encoding of integer (0) with Context Specific TAG, IMPLICIT | |
1684 | .*---------------------------------------------------------------------* | |
1685 | :xmp tab=0. | |
1686 | ||
1687 | <TC - DER + CER encoding of integer (0) with Context Specific TAG, IMPLICIT> | |
1688 | ||
1689 | <STATIC:ASN> | |
1690 | ||
1691 | TempA | |
1692 | ||
1693 | DEFINITIONS ::= | |
1694 | BEGIN | |
1695 | BERPDU ::= [0] IMPLICIT INTEGER | |
1696 | END | |
1697 | ||
1698 | <STATIC> | |
1699 | ||
1700 | import from TempA all; | |
1701 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1702 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1703 | ||
1704 | const BERPDU b := 0 | |
1705 | ||
1706 | <TTCN_TC:EXEC> | |
1707 | ||
1708 | if ((enc_DER_PDU(b) == '800100'O)and(enc_CER_PDU(b) == '800100'O)) {setverdict(pass);} else {setverdict(fail);} | |
1709 | ||
1710 | <RESULT> | |
1711 | ||
1712 | Overall verdict: pass | |
1713 | ||
1714 | <END_TC> | |
1715 | ||
1716 | :exmp. | |
1717 | ||
1718 | .*---------------------------------------------------------------------* | |
1719 | :h3. DER + CER encoding of integer (0) with PRIVATE TAG, IMPLICIT | |
1720 | .*---------------------------------------------------------------------* | |
1721 | :xmp tab=0. | |
1722 | ||
1723 | <TC - DER + CER encoding of integer (0) with PRIVATE TAG, IMPLICIT> | |
1724 | ||
1725 | <STATIC:ASN> | |
1726 | ||
1727 | TempA | |
1728 | ||
1729 | DEFINITIONS ::= | |
1730 | BEGIN | |
1731 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
1732 | END | |
1733 | ||
1734 | <STATIC> | |
1735 | ||
1736 | import from TempA all; | |
1737 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1738 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1739 | ||
1740 | const BERPDU b := 0 | |
1741 | ||
1742 | <TTCN_TC:EXEC> | |
1743 | ||
1744 | if ((enc_DER_PDU(b) == 'C10100'O)and(enc_CER_PDU(b) == 'C10100'O)) {setverdict(pass);} else {setverdict(fail);} | |
1745 | ||
1746 | <RESULT> | |
1747 | ||
1748 | Overall verdict: pass | |
1749 | ||
1750 | <END_TC> | |
1751 | ||
1752 | :exmp. | |
1753 | ||
1754 | .*---------------------------------------------------------------------* | |
1755 | :h3. DER + CER encoding of integer (0) with APPLICATION TAG, IMPLICIT | |
1756 | .*---------------------------------------------------------------------* | |
1757 | :xmp tab=0. | |
1758 | ||
1759 | <TC - DER + CER encoding of integer (0) with APPLICATION TAG, IMPLICIT> | |
1760 | ||
1761 | <STATIC:ASN> | |
1762 | ||
1763 | TempA | |
1764 | ||
1765 | DEFINITIONS ::= | |
1766 | BEGIN | |
1767 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
1768 | END | |
1769 | ||
1770 | <STATIC> | |
1771 | ||
1772 | import from TempA all; | |
1773 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1774 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1775 | ||
1776 | const BERPDU b := 0 | |
1777 | ||
1778 | <TTCN_TC:EXEC> | |
1779 | ||
1780 | if ((enc_DER_PDU(b) == '420100'O)and(enc_CER_PDU(b) == '420100'O)) {setverdict(pass);} else {setverdict(fail);} | |
1781 | ||
1782 | <RESULT> | |
1783 | ||
1784 | Overall verdict: pass | |
1785 | ||
1786 | <END_TC> | |
1787 | ||
1788 | :exmp. | |
1789 | ||
1790 | .*---------------------------------------------------------------------* | |
1791 | :h3. DER + CER encoding of integer (127) | |
1792 | .*---------------------------------------------------------------------* | |
1793 | :xmp tab=0. | |
1794 | ||
1795 | <TC - DER + CER encoding of integer (127) > | |
1796 | ||
1797 | <STATIC:ASN> | |
1798 | ||
1799 | TempA | |
1800 | ||
1801 | DEFINITIONS ::= | |
1802 | BEGIN | |
1803 | BERPDU ::= INTEGER | |
1804 | END | |
1805 | ||
1806 | <STATIC> | |
1807 | ||
1808 | import from TempA all; | |
1809 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1810 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1811 | ||
1812 | const BERPDU b := 127 | |
1813 | ||
1814 | <TTCN_TC:EXEC> | |
1815 | ||
1816 | if ((enc_DER_PDU(b) == '02017F'O)and(enc_CER_PDU(b) == '02017F'O)) {setverdict(pass);} else {setverdict(fail);} | |
1817 | ||
1818 | <RESULT> | |
1819 | ||
1820 | Overall verdict: pass | |
1821 | ||
1822 | <END_TC> | |
1823 | ||
1824 | :exmp. | |
1825 | ||
1826 | .*---------------------------------------------------------------------* | |
1827 | :h3. DER + CER encoding of integer (127) with Context Specific TAG, EXPLICIT | |
1828 | .*---------------------------------------------------------------------* | |
1829 | :xmp tab=0. | |
1830 | ||
1831 | <TC - DER + CER encoding of integer (127) with Context Specific TAG, EXPLICIT> | |
1832 | ||
1833 | <STATIC:ASN> | |
1834 | ||
1835 | TempA | |
1836 | ||
1837 | DEFINITIONS ::= | |
1838 | BEGIN | |
1839 | BERPDU ::= [0] EXPLICIT INTEGER | |
1840 | END | |
1841 | ||
1842 | <STATIC> | |
1843 | ||
1844 | import from TempA all; | |
1845 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1846 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1847 | ||
1848 | const BERPDU b := 127 | |
1849 | ||
1850 | <TTCN_TC:EXEC> | |
1851 | ||
1852 | if ((enc_DER_PDU(b) == 'A00302017F'O)and(enc_CER_PDU(b) == 'A08002017F0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
1853 | ||
1854 | <RESULT> | |
1855 | ||
1856 | Overall verdict: pass | |
1857 | ||
1858 | <END_TC> | |
1859 | ||
1860 | :exmp. | |
1861 | ||
1862 | .*---------------------------------------------------------------------* | |
1863 | :h3. DER + CER encoding of integer (127) with PRIVATE TAG, EXPLICIT | |
1864 | .*---------------------------------------------------------------------* | |
1865 | :xmp tab=0. | |
1866 | ||
1867 | <TC - DER + CER encoding of integer (127) with PRIVATE TAG, EXPLICIT> | |
1868 | ||
1869 | <STATIC:ASN> | |
1870 | ||
1871 | TempA | |
1872 | ||
1873 | DEFINITIONS ::= | |
1874 | BEGIN | |
1875 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
1876 | END | |
1877 | ||
1878 | <STATIC> | |
1879 | ||
1880 | import from TempA all; | |
1881 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1882 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1883 | ||
1884 | const BERPDU b := 127 | |
1885 | ||
1886 | <TTCN_TC:EXEC> | |
1887 | ||
1888 | if ((enc_DER_PDU(b) == 'E10302017F'O)and(enc_CER_PDU(b) == 'E18002017F0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
1889 | ||
1890 | <RESULT> | |
1891 | ||
1892 | Overall verdict: pass | |
1893 | ||
1894 | <END_TC> | |
1895 | ||
1896 | :exmp. | |
1897 | ||
1898 | .*---------------------------------------------------------------------* | |
1899 | :h3. DER + CER encoding of integer (127) with APPLICATION TAG, EXPLICIT | |
1900 | .*---------------------------------------------------------------------* | |
1901 | :xmp tab=0. | |
1902 | ||
1903 | <TC - DER + CER encoding of integer (127) with APPLICATION TAG, EXPLICIT> | |
1904 | ||
1905 | <STATIC:ASN> | |
1906 | ||
1907 | TempA | |
1908 | ||
1909 | DEFINITIONS ::= | |
1910 | BEGIN | |
1911 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
1912 | END | |
1913 | ||
1914 | <STATIC> | |
1915 | ||
1916 | import from TempA all; | |
1917 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1918 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1919 | ||
1920 | const BERPDU b := 127 | |
1921 | ||
1922 | <TTCN_TC:EXEC> | |
1923 | ||
1924 | if ((enc_DER_PDU(b) == '620302017F'O)and(enc_CER_PDU(b) == '628002017F0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
1925 | ||
1926 | <RESULT> | |
1927 | ||
1928 | Overall verdict: pass | |
1929 | ||
1930 | <END_TC> | |
1931 | ||
1932 | :exmp. | |
1933 | ||
1934 | .*---------------------------------------------------------------------* | |
1935 | :h3. DER + CER encoding of integer (127) with Context Specific TAG, IMPLICIT | |
1936 | .*---------------------------------------------------------------------* | |
1937 | :xmp tab=0. | |
1938 | ||
1939 | <TC - DER + CER encoding of integer (127) with Context Specific TAG, IMPLICIT> | |
1940 | ||
1941 | <STATIC:ASN> | |
1942 | ||
1943 | TempA | |
1944 | ||
1945 | DEFINITIONS ::= | |
1946 | BEGIN | |
1947 | BERPDU ::= [0] IMPLICIT INTEGER | |
1948 | END | |
1949 | ||
1950 | <STATIC> | |
1951 | ||
1952 | import from TempA all; | |
1953 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1954 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1955 | ||
1956 | const BERPDU b := 127 | |
1957 | ||
1958 | <TTCN_TC:EXEC> | |
1959 | ||
1960 | if ((enc_DER_PDU(b) == '80017F'O)and(enc_CER_PDU(b) == '80017F'O)) {setverdict(pass);} else {setverdict(fail);} | |
1961 | ||
1962 | <RESULT> | |
1963 | ||
1964 | Overall verdict: pass | |
1965 | ||
1966 | <END_TC> | |
1967 | ||
1968 | :exmp. | |
1969 | ||
1970 | .*---------------------------------------------------------------------* | |
1971 | :h3. DER + CER encoding of integer (127) with PRIVATE TAG, IMPLICIT | |
1972 | .*---------------------------------------------------------------------* | |
1973 | :xmp tab=0. | |
1974 | ||
1975 | <TC - DER + CER encoding of integer (127) with PRIVATE TAG, IMPLICIT> | |
1976 | ||
1977 | <STATIC:ASN> | |
1978 | ||
1979 | TempA | |
1980 | ||
1981 | DEFINITIONS ::= | |
1982 | BEGIN | |
1983 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
1984 | END | |
1985 | ||
1986 | <STATIC> | |
1987 | ||
1988 | import from TempA all; | |
1989 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
1990 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
1991 | ||
1992 | const BERPDU b := 127 | |
1993 | ||
1994 | <TTCN_TC:EXEC> | |
1995 | ||
1996 | if ((enc_DER_PDU(b) == 'C1017F'O)and(enc_CER_PDU(b) == 'C1017F'O)) {setverdict(pass);} else {setverdict(fail);} | |
1997 | ||
1998 | <RESULT> | |
1999 | ||
2000 | Overall verdict: pass | |
2001 | ||
2002 | <END_TC> | |
2003 | ||
2004 | :exmp. | |
2005 | ||
2006 | .*---------------------------------------------------------------------* | |
2007 | :h3. DER + CER encoding of integer (127) with APPLICATION TAG, IMPLICIT | |
2008 | .*---------------------------------------------------------------------* | |
2009 | :xmp tab=0. | |
2010 | ||
2011 | <TC - DER + CER encoding of integer (127) with APPLICATION TAG, IMPLICIT> | |
2012 | ||
2013 | <STATIC:ASN> | |
2014 | ||
2015 | TempA | |
2016 | ||
2017 | DEFINITIONS ::= | |
2018 | BEGIN | |
2019 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
2020 | END | |
2021 | ||
2022 | <STATIC> | |
2023 | ||
2024 | import from TempA all; | |
2025 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2026 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2027 | ||
2028 | const BERPDU b := 127 | |
2029 | ||
2030 | <TTCN_TC:EXEC> | |
2031 | ||
2032 | if ((enc_DER_PDU(b) == '42017F'O)and(enc_CER_PDU(b) == '42017F'O)) {setverdict(pass);} else {setverdict(fail);} | |
2033 | ||
2034 | <RESULT> | |
2035 | ||
2036 | Overall verdict: pass | |
2037 | ||
2038 | <END_TC> | |
2039 | ||
2040 | :exmp. | |
2041 | ||
2042 | .*---------------------------------------------------------------------* | |
2043 | :h3. DER + CER encoding of integer (-128) | |
2044 | .*---------------------------------------------------------------------* | |
2045 | :xmp tab=0. | |
2046 | ||
2047 | <TC - DER + CER encoding of integer (-128) > | |
2048 | ||
2049 | <STATIC:ASN> | |
2050 | ||
2051 | TempA | |
2052 | ||
2053 | DEFINITIONS ::= | |
2054 | BEGIN | |
2055 | BERPDU ::= INTEGER | |
2056 | END | |
2057 | ||
2058 | <STATIC> | |
2059 | ||
2060 | import from TempA all; | |
2061 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2062 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2063 | ||
2064 | const BERPDU b := -128 | |
2065 | ||
2066 | <TTCN_TC:EXEC> | |
2067 | ||
2068 | if ((enc_DER_PDU(b) == '020180'O)and(enc_CER_PDU(b) == '020180'O)) {setverdict(pass);} else {setverdict(fail);} | |
2069 | ||
2070 | <RESULT> | |
2071 | ||
2072 | Overall verdict: pass | |
2073 | ||
2074 | <END_TC> | |
2075 | ||
2076 | :exmp. | |
2077 | ||
2078 | .*---------------------------------------------------------------------* | |
2079 | :h3. DER + CER encoding of integer (-128) with Context Specific TAG, EXPLICIT | |
2080 | .*---------------------------------------------------------------------* | |
2081 | :xmp tab=0. | |
2082 | ||
2083 | <TC - DER + CER encoding of integer (-128) with Context Specific TAG, EXPLICIT> | |
2084 | ||
2085 | <STATIC:ASN> | |
2086 | ||
2087 | TempA | |
2088 | ||
2089 | DEFINITIONS ::= | |
2090 | BEGIN | |
2091 | BERPDU ::= [0] EXPLICIT INTEGER | |
2092 | END | |
2093 | ||
2094 | <STATIC> | |
2095 | ||
2096 | import from TempA all; | |
2097 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2098 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2099 | ||
2100 | const BERPDU b := -128 | |
2101 | ||
2102 | <TTCN_TC:EXEC> | |
2103 | ||
2104 | if ((enc_DER_PDU(b) == 'A003020180'O)and(enc_CER_PDU(b) == 'A0800201800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
2105 | ||
2106 | <RESULT> | |
2107 | ||
2108 | Overall verdict: pass | |
2109 | ||
2110 | <END_TC> | |
2111 | ||
2112 | :exmp. | |
2113 | ||
2114 | .*---------------------------------------------------------------------* | |
2115 | :h3. DER + CER encoding of integer (-128) with PRIVATE TAG, EXPLICIT | |
2116 | .*---------------------------------------------------------------------* | |
2117 | :xmp tab=0. | |
2118 | ||
2119 | <TC - DER + CER encoding of integer (-128) with PRIVATE TAG, EXPLICIT> | |
2120 | ||
2121 | <STATIC:ASN> | |
2122 | ||
2123 | TempA | |
2124 | ||
2125 | DEFINITIONS ::= | |
2126 | BEGIN | |
2127 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
2128 | END | |
2129 | ||
2130 | <STATIC> | |
2131 | ||
2132 | import from TempA all; | |
2133 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2134 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2135 | ||
2136 | const BERPDU b := -128 | |
2137 | ||
2138 | <TTCN_TC:EXEC> | |
2139 | ||
2140 | if ((enc_DER_PDU(b) == 'E103020180'O)and(enc_CER_PDU(b) == 'E1800201800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
2141 | ||
2142 | <RESULT> | |
2143 | ||
2144 | Overall verdict: pass | |
2145 | ||
2146 | <END_TC> | |
2147 | ||
2148 | :exmp. | |
2149 | ||
2150 | .*---------------------------------------------------------------------* | |
2151 | :h3. DER + CER encoding of integer (-128) with APPLICATION TAG, EXPLICIT | |
2152 | .*---------------------------------------------------------------------* | |
2153 | :xmp tab=0. | |
2154 | ||
2155 | <TC - DER + CER encoding of integer (-128) with APPLICATION TAG, EXPLICIT> | |
2156 | ||
2157 | <STATIC:ASN> | |
2158 | ||
2159 | TempA | |
2160 | ||
2161 | DEFINITIONS ::= | |
2162 | BEGIN | |
2163 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
2164 | END | |
2165 | ||
2166 | <STATIC> | |
2167 | ||
2168 | import from TempA all; | |
2169 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2170 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2171 | ||
2172 | const BERPDU b := -128 | |
2173 | ||
2174 | <TTCN_TC:EXEC> | |
2175 | ||
2176 | if ((enc_DER_PDU(b) == '6203020180'O)and(enc_CER_PDU(b) == '62800201800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
2177 | ||
2178 | <RESULT> | |
2179 | ||
2180 | Overall verdict: pass | |
2181 | ||
2182 | <END_TC> | |
2183 | ||
2184 | :exmp. | |
2185 | ||
2186 | .*---------------------------------------------------------------------* | |
2187 | :h3. DER + CER encoding of integer (-128) with Context Specific TAG, IMPLICIT | |
2188 | .*---------------------------------------------------------------------* | |
2189 | :xmp tab=0. | |
2190 | ||
2191 | <TC - DER + CER encoding of integer (-128) with Context Specific TAG, IMPLICIT> | |
2192 | ||
2193 | <STATIC:ASN> | |
2194 | ||
2195 | TempA | |
2196 | ||
2197 | DEFINITIONS ::= | |
2198 | BEGIN | |
2199 | BERPDU ::= [0] IMPLICIT INTEGER | |
2200 | END | |
2201 | ||
2202 | <STATIC> | |
2203 | ||
2204 | import from TempA all; | |
2205 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2206 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2207 | ||
2208 | const BERPDU b := -128 | |
2209 | ||
2210 | <TTCN_TC:EXEC> | |
2211 | ||
2212 | if ((enc_DER_PDU(b) == '800180'O)and(enc_CER_PDU(b) == '800180'O)) {setverdict(pass);} else {setverdict(fail);} | |
2213 | ||
2214 | <RESULT> | |
2215 | ||
2216 | Overall verdict: pass | |
2217 | ||
2218 | <END_TC> | |
2219 | ||
2220 | :exmp. | |
2221 | ||
2222 | .*---------------------------------------------------------------------* | |
2223 | :h3. DER + CER encoding of integer (-128) with PRIVATE TAG, IMPLICIT | |
2224 | .*---------------------------------------------------------------------* | |
2225 | :xmp tab=0. | |
2226 | ||
2227 | <TC - DER + CER encoding of integer (-128) with PRIVATE TAG, IMPLICIT> | |
2228 | ||
2229 | <STATIC:ASN> | |
2230 | ||
2231 | TempA | |
2232 | ||
2233 | DEFINITIONS ::= | |
2234 | BEGIN | |
2235 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
2236 | END | |
2237 | ||
2238 | <STATIC> | |
2239 | ||
2240 | import from TempA all; | |
2241 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2242 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2243 | ||
2244 | const BERPDU b := -128 | |
2245 | ||
2246 | <TTCN_TC:EXEC> | |
2247 | ||
2248 | if ((enc_DER_PDU(b) == 'C10180'O)and(enc_CER_PDU(b) == 'C10180'O)) {setverdict(pass);} else {setverdict(fail);} | |
2249 | ||
2250 | <RESULT> | |
2251 | ||
2252 | Overall verdict: pass | |
2253 | ||
2254 | <END_TC> | |
2255 | ||
2256 | :exmp. | |
2257 | ||
2258 | .*---------------------------------------------------------------------* | |
2259 | :h3. DER + CER encoding of integer (-128) with APPLICATION TAG, IMPLICIT | |
2260 | .*---------------------------------------------------------------------* | |
2261 | :xmp tab=0. | |
2262 | ||
2263 | <TC - DER + CER encoding of integer (-128) with APPLICATION TAG, IMPLICIT> | |
2264 | ||
2265 | <STATIC:ASN> | |
2266 | ||
2267 | TempA | |
2268 | ||
2269 | DEFINITIONS ::= | |
2270 | BEGIN | |
2271 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
2272 | END | |
2273 | ||
2274 | <STATIC> | |
2275 | ||
2276 | import from TempA all; | |
2277 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2278 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2279 | ||
2280 | const BERPDU b := -128 | |
2281 | ||
2282 | <TTCN_TC:EXEC> | |
2283 | ||
2284 | if ((enc_DER_PDU(b) == '420180'O)and(enc_CER_PDU(b) == '420180'O)) {setverdict(pass);} else {setverdict(fail);} | |
2285 | ||
2286 | <RESULT> | |
2287 | ||
2288 | Overall verdict: pass | |
2289 | ||
2290 | <END_TC> | |
2291 | ||
2292 | :exmp. | |
2293 | ||
2294 | .*---------------------------------------------------------------------* | |
2295 | :h3. DER + CER encoding of integer (-5) | |
2296 | .*---------------------------------------------------------------------* | |
2297 | :xmp tab=0. | |
2298 | ||
2299 | <TC - DER + CER encoding of integer (-5)> | |
2300 | ||
2301 | <STATIC:ASN> | |
2302 | ||
2303 | TempA | |
2304 | ||
2305 | DEFINITIONS ::= | |
2306 | BEGIN | |
2307 | BERPDU ::= INTEGER | |
2308 | END | |
2309 | ||
2310 | <STATIC> | |
2311 | ||
2312 | import from TempA all; | |
2313 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2314 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2315 | ||
2316 | const BERPDU b := -5 | |
2317 | ||
2318 | <TTCN_TC:EXEC> | |
2319 | ||
2320 | if ((enc_DER_PDU(b) == '0201FB'O)and(enc_CER_PDU(b) == '0201FB'O)) {setverdict(pass);} else {setverdict(fail);} | |
2321 | ||
2322 | <RESULT> | |
2323 | ||
2324 | Overall verdict: pass | |
2325 | ||
2326 | <END_TC> | |
2327 | ||
2328 | :exmp. | |
2329 | ||
2330 | .*---------------------------------------------------------------------* | |
2331 | :h3. DER + CER encoding of integer (-5) with Context Specific TAG, EXPLICIT | |
2332 | .*---------------------------------------------------------------------* | |
2333 | :xmp tab=0. | |
2334 | ||
2335 | <TC - DER + CER encoding of integer (-5) with Context Specific TAG, EXPLICIT> | |
2336 | ||
2337 | <STATIC:ASN> | |
2338 | ||
2339 | TempA | |
2340 | ||
2341 | DEFINITIONS ::= | |
2342 | BEGIN | |
2343 | BERPDU ::= [0] EXPLICIT INTEGER | |
2344 | END | |
2345 | ||
2346 | <STATIC> | |
2347 | ||
2348 | import from TempA all; | |
2349 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2350 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2351 | ||
2352 | const BERPDU b := -5 | |
2353 | ||
2354 | <TTCN_TC:EXEC> | |
2355 | ||
2356 | if ((enc_DER_PDU(b) == 'A0030201FB'O)and(enc_CER_PDU(b) == 'A0800201FB0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
2357 | ||
2358 | <RESULT> | |
2359 | ||
2360 | Overall verdict: pass | |
2361 | ||
2362 | <END_TC> | |
2363 | ||
2364 | :exmp. | |
2365 | ||
2366 | .*---------------------------------------------------------------------* | |
2367 | :h3. DER + CER encoding of integer (-5) with PRIVATE TAG, EXPLICIT | |
2368 | .*---------------------------------------------------------------------* | |
2369 | :xmp tab=0. | |
2370 | ||
2371 | <TC - DER + CER encoding of integer (-5) with PRIVATE TAG, EXPLICIT> | |
2372 | ||
2373 | <STATIC:ASN> | |
2374 | ||
2375 | TempA | |
2376 | ||
2377 | DEFINITIONS ::= | |
2378 | BEGIN | |
2379 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
2380 | END | |
2381 | ||
2382 | <STATIC> | |
2383 | ||
2384 | import from TempA all; | |
2385 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2386 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2387 | ||
2388 | const BERPDU b := -5 | |
2389 | ||
2390 | <TTCN_TC:EXEC> | |
2391 | ||
2392 | if ((enc_DER_PDU(b) == 'E1030201FB'O)and(enc_CER_PDU(b) == 'E1800201FB0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
2393 | ||
2394 | <RESULT> | |
2395 | ||
2396 | Overall verdict: pass | |
2397 | ||
2398 | <END_TC> | |
2399 | ||
2400 | :exmp. | |
2401 | ||
2402 | .*---------------------------------------------------------------------* | |
2403 | :h3. DER + CER encoding of integer (-5) with APPLICATION TAG, EXPLICIT | |
2404 | .*---------------------------------------------------------------------* | |
2405 | :xmp tab=0. | |
2406 | ||
2407 | <TC - DER + CER encoding of integer (-5) with APPLICATION TAG, EXPLICIT> | |
2408 | ||
2409 | <STATIC:ASN> | |
2410 | ||
2411 | TempA | |
2412 | ||
2413 | DEFINITIONS ::= | |
2414 | BEGIN | |
2415 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
2416 | END | |
2417 | ||
2418 | <STATIC> | |
2419 | ||
2420 | import from TempA all; | |
2421 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2422 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2423 | ||
2424 | const BERPDU b := -5 | |
2425 | ||
2426 | <TTCN_TC:EXEC> | |
2427 | ||
2428 | if ((enc_DER_PDU(b) == '62030201FB'O)and(enc_CER_PDU(b) == '62800201FB0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
2429 | ||
2430 | <RESULT> | |
2431 | ||
2432 | Overall verdict: pass | |
2433 | ||
2434 | <END_TC> | |
2435 | ||
2436 | :exmp. | |
2437 | ||
2438 | .*---------------------------------------------------------------------* | |
2439 | :h3. DER + CER encoding of integer (-5) with Context Specific TAG, IMPLICIT | |
2440 | .*---------------------------------------------------------------------* | |
2441 | :xmp tab=0. | |
2442 | ||
2443 | <TC - DER + CER encoding of integer (-5) with Context Specific TAG, IMPLICIT> | |
2444 | ||
2445 | <STATIC:ASN> | |
2446 | ||
2447 | TempA | |
2448 | ||
2449 | DEFINITIONS ::= | |
2450 | BEGIN | |
2451 | BERPDU ::= [0] IMPLICIT INTEGER | |
2452 | END | |
2453 | ||
2454 | <STATIC> | |
2455 | ||
2456 | import from TempA all; | |
2457 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2458 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2459 | ||
2460 | const BERPDU b := -5 | |
2461 | ||
2462 | <TTCN_TC:EXEC> | |
2463 | ||
2464 | if ((enc_DER_PDU(b) == '8001FB'O)and(enc_CER_PDU(b) == '8001FB'O)) {setverdict(pass);} else {setverdict(fail);} | |
2465 | ||
2466 | <RESULT> | |
2467 | ||
2468 | Overall verdict: pass | |
2469 | ||
2470 | <END_TC> | |
2471 | ||
2472 | :exmp. | |
2473 | ||
2474 | .*---------------------------------------------------------------------* | |
2475 | :h3. DER + CER encoding of integer (-5) with PRIVATE TAG, IMPLICIT | |
2476 | .*---------------------------------------------------------------------* | |
2477 | :xmp tab=0. | |
2478 | ||
2479 | <TC - DER + CER encoding of integer (-5) with PRIVATE TAG, IMPLICIT> | |
2480 | ||
2481 | <STATIC:ASN> | |
2482 | ||
2483 | TempA | |
2484 | ||
2485 | DEFINITIONS ::= | |
2486 | BEGIN | |
2487 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
2488 | END | |
2489 | ||
2490 | <STATIC> | |
2491 | ||
2492 | import from TempA all; | |
2493 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2494 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2495 | ||
2496 | const BERPDU b := -5 | |
2497 | ||
2498 | <TTCN_TC:EXEC> | |
2499 | ||
2500 | if ((enc_DER_PDU(b) == 'C101FB'O)and(enc_CER_PDU(b) == 'C101FB'O)) {setverdict(pass);} else {setverdict(fail);} | |
2501 | ||
2502 | <RESULT> | |
2503 | ||
2504 | Overall verdict: pass | |
2505 | ||
2506 | <END_TC> | |
2507 | ||
2508 | :exmp. | |
2509 | ||
2510 | .*---------------------------------------------------------------------* | |
2511 | :h3. DER + CER encoding of integer (-5) with APPLICATION TAG, IMPLICIT | |
2512 | .*---------------------------------------------------------------------* | |
2513 | :xmp tab=0. | |
2514 | ||
2515 | <TC - DER + CER encoding of integer (-5) with APPLICATION TAG, IMPLICIT> | |
2516 | ||
2517 | <STATIC:ASN> | |
2518 | ||
2519 | TempA | |
2520 | ||
2521 | DEFINITIONS ::= | |
2522 | BEGIN | |
2523 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
2524 | END | |
2525 | ||
2526 | <STATIC> | |
2527 | ||
2528 | import from TempA all; | |
2529 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2530 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2531 | ||
2532 | const BERPDU b := -5 | |
2533 | ||
2534 | <TTCN_TC:EXEC> | |
2535 | ||
2536 | if ((enc_DER_PDU(b) == '4201FB'O)and(enc_CER_PDU(b) == '4201FB'O)) {setverdict(pass);} else {setverdict(fail);} | |
2537 | ||
2538 | <RESULT> | |
2539 | ||
2540 | Overall verdict: pass | |
2541 | ||
2542 | <END_TC> | |
2543 | ||
2544 | :exmp. | |
2545 | ||
2546 | .*---------------------------------------------------------------------* | |
2547 | :h3. DER + CER encoding of integer (128) | |
2548 | .*---------------------------------------------------------------------* | |
2549 | :xmp tab=0. | |
2550 | ||
2551 | <TC - DER + CER encoding of integer (128)> | |
2552 | ||
2553 | <STATIC:ASN> | |
2554 | ||
2555 | TempA | |
2556 | ||
2557 | DEFINITIONS ::= | |
2558 | BEGIN | |
2559 | BERPDU ::= INTEGER | |
2560 | END | |
2561 | ||
2562 | <STATIC> | |
2563 | ||
2564 | import from TempA all; | |
2565 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2566 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2567 | ||
2568 | const BERPDU b := 128 | |
2569 | ||
2570 | <TTCN_TC:EXEC> | |
2571 | ||
2572 | if ((enc_DER_PDU(b) == '02020080'O)and(enc_CER_PDU(b) == '02020080'O)) {setverdict(pass);} else {setverdict(fail);} | |
2573 | ||
2574 | <RESULT> | |
2575 | ||
2576 | Overall verdict: pass | |
2577 | ||
2578 | <END_TC> | |
2579 | ||
2580 | :exmp. | |
2581 | ||
2582 | .*---------------------------------------------------------------------* | |
2583 | :h3. DER + CER encoding of integer (128) with Context Specific TAG, EXPLICIT | |
2584 | .*---------------------------------------------------------------------* | |
2585 | :xmp tab=0. | |
2586 | ||
2587 | <TC - DER + CER encoding of integer (128) with Context Specific TAG, EXPLICIT> | |
2588 | ||
2589 | <STATIC:ASN> | |
2590 | ||
2591 | TempA | |
2592 | ||
2593 | DEFINITIONS ::= | |
2594 | BEGIN | |
2595 | BERPDU ::= [0] EXPLICIT INTEGER | |
2596 | END | |
2597 | ||
2598 | <STATIC> | |
2599 | ||
2600 | import from TempA all; | |
2601 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2602 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2603 | ||
2604 | const BERPDU b := 128 | |
2605 | ||
2606 | <TTCN_TC:EXEC> | |
2607 | ||
2608 | if ((enc_DER_PDU(b) == 'A00402020080'O)and(enc_CER_PDU(b) == 'A080020200800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
2609 | ||
2610 | <RESULT> | |
2611 | ||
2612 | Overall verdict: pass | |
2613 | ||
2614 | <END_TC> | |
2615 | ||
2616 | :exmp. | |
2617 | ||
2618 | .*---------------------------------------------------------------------* | |
2619 | :h3. DER + CER encoding of integer (128) with PRIVATE TAG, EXPLICIT | |
2620 | .*---------------------------------------------------------------------* | |
2621 | :xmp tab=0. | |
2622 | ||
2623 | <TC - DER + CER encoding of integer (128) with PRIVATE TAG, EXPLICIT> | |
2624 | ||
2625 | <STATIC:ASN> | |
2626 | ||
2627 | TempA | |
2628 | ||
2629 | DEFINITIONS ::= | |
2630 | BEGIN | |
2631 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
2632 | END | |
2633 | ||
2634 | <STATIC> | |
2635 | ||
2636 | import from TempA all; | |
2637 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2638 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2639 | ||
2640 | const BERPDU b := 128 | |
2641 | ||
2642 | <TTCN_TC:EXEC> | |
2643 | ||
2644 | if ((enc_DER_PDU(b) == 'E10402020080'O)and(enc_CER_PDU(b) == 'E180020200800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
2645 | ||
2646 | <RESULT> | |
2647 | ||
2648 | Overall verdict: pass | |
2649 | ||
2650 | <END_TC> | |
2651 | ||
2652 | :exmp. | |
2653 | ||
2654 | .*---------------------------------------------------------------------* | |
2655 | :h3. DER + CER encoding of integer (128) with APPLICATION TAG, EXPLICIT | |
2656 | .*---------------------------------------------------------------------* | |
2657 | :xmp tab=0. | |
2658 | ||
2659 | <TC - DER + CER encoding of integer (128) with APPLICATION TAG, EXPLICIT> | |
2660 | ||
2661 | <STATIC:ASN> | |
2662 | ||
2663 | TempA | |
2664 | ||
2665 | DEFINITIONS ::= | |
2666 | BEGIN | |
2667 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
2668 | END | |
2669 | ||
2670 | <STATIC> | |
2671 | ||
2672 | import from TempA all; | |
2673 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2674 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2675 | ||
2676 | const BERPDU b := 128 | |
2677 | ||
2678 | <TTCN_TC:EXEC> | |
2679 | ||
2680 | if ((enc_DER_PDU(b) == '620402020080'O)and(enc_CER_PDU(b) == '6280020200800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
2681 | ||
2682 | <RESULT> | |
2683 | ||
2684 | Overall verdict: pass | |
2685 | ||
2686 | <END_TC> | |
2687 | ||
2688 | :exmp. | |
2689 | ||
2690 | .*---------------------------------------------------------------------* | |
2691 | :h3. DER + CER encoding of integer (128) with Context Specific TAG, IMPLICIT | |
2692 | .*---------------------------------------------------------------------* | |
2693 | :xmp tab=0. | |
2694 | ||
2695 | <TC - DER + CER encoding of integer (128) with Context Specific TAG, IMPLICIT> | |
2696 | ||
2697 | <STATIC:ASN> | |
2698 | ||
2699 | TempA | |
2700 | ||
2701 | DEFINITIONS ::= | |
2702 | BEGIN | |
2703 | BERPDU ::= [0] IMPLICIT INTEGER | |
2704 | END | |
2705 | ||
2706 | <STATIC> | |
2707 | ||
2708 | import from TempA all; | |
2709 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2710 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2711 | ||
2712 | const BERPDU b := 128 | |
2713 | ||
2714 | <TTCN_TC:EXEC> | |
2715 | ||
2716 | if ((enc_DER_PDU(b) == '80020080'O)and(enc_CER_PDU(b) == '80020080'O)) {setverdict(pass);} else {setverdict(fail);} | |
2717 | ||
2718 | <RESULT> | |
2719 | ||
2720 | Overall verdict: pass | |
2721 | ||
2722 | <END_TC> | |
2723 | ||
2724 | :exmp. | |
2725 | ||
2726 | .*---------------------------------------------------------------------* | |
2727 | :h3. DER + CER encoding of integer (128) with PRIVATE TAG, IMPLICIT | |
2728 | .*---------------------------------------------------------------------* | |
2729 | :xmp tab=0. | |
2730 | ||
2731 | <TC - DER + CER encoding of integer (128) with PRIVATE TAG, IMPLICIT> | |
2732 | ||
2733 | <STATIC:ASN> | |
2734 | ||
2735 | TempA | |
2736 | ||
2737 | DEFINITIONS ::= | |
2738 | BEGIN | |
2739 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
2740 | END | |
2741 | ||
2742 | <STATIC> | |
2743 | ||
2744 | import from TempA all; | |
2745 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2746 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2747 | ||
2748 | const BERPDU b := 128 | |
2749 | ||
2750 | <TTCN_TC:EXEC> | |
2751 | ||
2752 | if ((enc_DER_PDU(b) == 'C1020080'O)and(enc_CER_PDU(b) == 'C1020080'O)) {setverdict(pass);} else {setverdict(fail);} | |
2753 | ||
2754 | <RESULT> | |
2755 | ||
2756 | Overall verdict: pass | |
2757 | ||
2758 | <END_TC> | |
2759 | ||
2760 | :exmp. | |
2761 | ||
2762 | .*---------------------------------------------------------------------* | |
2763 | :h3. DER + CER encoding of integer (128) with APPLICATION TAG, IMPLICIT | |
2764 | .*---------------------------------------------------------------------* | |
2765 | :xmp tab=0. | |
2766 | ||
2767 | <TC - DER + CER encoding of integer (128) with APPLICATION TAG, IMPLICIT> | |
2768 | ||
2769 | <STATIC:ASN> | |
2770 | ||
2771 | TempA | |
2772 | ||
2773 | DEFINITIONS ::= | |
2774 | BEGIN | |
2775 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
2776 | END | |
2777 | ||
2778 | <STATIC> | |
2779 | ||
2780 | import from TempA all; | |
2781 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2782 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2783 | ||
2784 | const BERPDU b := 128 | |
2785 | ||
2786 | <TTCN_TC:EXEC> | |
2787 | ||
2788 | if ((enc_DER_PDU(b) == '42020080'O)and(enc_CER_PDU(b) == '42020080'O)) {setverdict(pass);} else {setverdict(fail);} | |
2789 | ||
2790 | <RESULT> | |
2791 | ||
2792 | Overall verdict: pass | |
2793 | ||
2794 | <END_TC> | |
2795 | ||
2796 | :exmp. | |
2797 | ||
2798 | .*---------------------------------------------------------------------* | |
2799 | :h3. DER + CER encoding of integer (-129) | |
2800 | .*---------------------------------------------------------------------* | |
2801 | :xmp tab=0. | |
2802 | ||
2803 | <TC - DER + CER encoding of integer (-129)> | |
2804 | ||
2805 | <STATIC:ASN> | |
2806 | ||
2807 | TempA | |
2808 | ||
2809 | DEFINITIONS ::= | |
2810 | BEGIN | |
2811 | BERPDU ::= INTEGER | |
2812 | END | |
2813 | ||
2814 | <STATIC> | |
2815 | ||
2816 | import from TempA all; | |
2817 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2818 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2819 | ||
2820 | const BERPDU b := -129 | |
2821 | ||
2822 | <TTCN_TC:EXEC> | |
2823 | ||
2824 | if ((enc_DER_PDU(b) == '0202FF7F'O)and(enc_CER_PDU(b) == '0202FF7F'O)) {setverdict(pass);} else {setverdict(fail);} | |
2825 | ||
2826 | <RESULT> | |
2827 | ||
2828 | Overall verdict: pass | |
2829 | ||
2830 | <END_TC> | |
2831 | ||
2832 | :exmp. | |
2833 | ||
2834 | .*---------------------------------------------------------------------* | |
2835 | :h3. DER + CER encoding of integer (-129) with Context Specific TAG, EXPLICIT | |
2836 | .*---------------------------------------------------------------------* | |
2837 | :xmp tab=0. | |
2838 | ||
2839 | <TC - DER + CER encoding of integer (-129) with Context Specific TAG, EXPLICIT> | |
2840 | ||
2841 | <STATIC:ASN> | |
2842 | ||
2843 | TempA | |
2844 | ||
2845 | DEFINITIONS ::= | |
2846 | BEGIN | |
2847 | BERPDU ::= [0] EXPLICIT INTEGER | |
2848 | END | |
2849 | ||
2850 | <STATIC> | |
2851 | ||
2852 | import from TempA all; | |
2853 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2854 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2855 | ||
2856 | const BERPDU b := -129 | |
2857 | ||
2858 | <TTCN_TC:EXEC> | |
2859 | ||
2860 | if ((enc_DER_PDU(b) == 'A0040202FF7F'O)and(enc_CER_PDU(b) == 'A0800202FF7F0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
2861 | ||
2862 | <RESULT> | |
2863 | ||
2864 | Overall verdict: pass | |
2865 | ||
2866 | <END_TC> | |
2867 | ||
2868 | :exmp. | |
2869 | ||
2870 | .*---------------------------------------------------------------------* | |
2871 | :h3. DER + CER encoding of integer (-129) with PRIVATE TAG, EXPLICIT | |
2872 | .*---------------------------------------------------------------------* | |
2873 | :xmp tab=0. | |
2874 | ||
2875 | <TC - DER + CER encoding of integer (-129) with PRIVATE TAG, EXPLICIT> | |
2876 | ||
2877 | <STATIC:ASN> | |
2878 | ||
2879 | TempA | |
2880 | ||
2881 | DEFINITIONS ::= | |
2882 | BEGIN | |
2883 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
2884 | END | |
2885 | ||
2886 | <STATIC> | |
2887 | ||
2888 | import from TempA all; | |
2889 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2890 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2891 | ||
2892 | const BERPDU b := -129 | |
2893 | ||
2894 | <TTCN_TC:EXEC> | |
2895 | ||
2896 | if ((enc_DER_PDU(b) == 'E1040202FF7F'O)and(enc_CER_PDU(b) == 'E1800202FF7F0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
2897 | ||
2898 | <RESULT> | |
2899 | ||
2900 | Overall verdict: pass | |
2901 | ||
2902 | <END_TC> | |
2903 | ||
2904 | :exmp. | |
2905 | ||
2906 | .*---------------------------------------------------------------------* | |
2907 | :h3. DER + CER encoding of integer (-129) with APPLICATION TAG, EXPLICIT | |
2908 | .*---------------------------------------------------------------------* | |
2909 | :xmp tab=0. | |
2910 | ||
2911 | <TC - DER + CER encoding of integer (-129) with APPLICATION TAG, EXPLICIT> | |
2912 | ||
2913 | <STATIC:ASN> | |
2914 | ||
2915 | TempA | |
2916 | ||
2917 | DEFINITIONS ::= | |
2918 | BEGIN | |
2919 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
2920 | END | |
2921 | ||
2922 | <STATIC> | |
2923 | ||
2924 | import from TempA all; | |
2925 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2926 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2927 | ||
2928 | const BERPDU b := -129 | |
2929 | ||
2930 | <TTCN_TC:EXEC> | |
2931 | ||
2932 | if ((enc_DER_PDU(b) == '62040202FF7F'O)and(enc_CER_PDU(b) == '62800202FF7F0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
2933 | ||
2934 | <RESULT> | |
2935 | ||
2936 | Overall verdict: pass | |
2937 | ||
2938 | <END_TC> | |
2939 | ||
2940 | :exmp. | |
2941 | ||
2942 | .*---------------------------------------------------------------------* | |
2943 | :h3. DER + CER encoding of integer (-129) with Context Specific TAG, IMPLICIT | |
2944 | .*---------------------------------------------------------------------* | |
2945 | :xmp tab=0. | |
2946 | ||
2947 | <TC - DER + CER encoding of integer (-129) with Context Specific TAG, IMPLICIT> | |
2948 | ||
2949 | <STATIC:ASN> | |
2950 | ||
2951 | TempA | |
2952 | ||
2953 | DEFINITIONS ::= | |
2954 | BEGIN | |
2955 | BERPDU ::= [0] IMPLICIT INTEGER | |
2956 | END | |
2957 | ||
2958 | <STATIC> | |
2959 | ||
2960 | import from TempA all; | |
2961 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2962 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2963 | ||
2964 | const BERPDU b := -129 | |
2965 | ||
2966 | <TTCN_TC:EXEC> | |
2967 | ||
2968 | if ((enc_DER_PDU(b) == '8002FF7F'O)and(enc_CER_PDU(b) == '8002FF7F'O)) {setverdict(pass);} else {setverdict(fail);} | |
2969 | ||
2970 | <RESULT> | |
2971 | ||
2972 | Overall verdict: pass | |
2973 | ||
2974 | <END_TC> | |
2975 | ||
2976 | :exmp. | |
2977 | ||
2978 | .*---------------------------------------------------------------------* | |
2979 | :h3. DER + CER encoding of integer (-129) with PRIVATE TAG, IMPLICIT | |
2980 | .*---------------------------------------------------------------------* | |
2981 | :xmp tab=0. | |
2982 | ||
2983 | <TC - DER + CER encoding of integer (-129) with PRIVATE TAG, IMPLICIT> | |
2984 | ||
2985 | <STATIC:ASN> | |
2986 | ||
2987 | TempA | |
2988 | ||
2989 | DEFINITIONS ::= | |
2990 | BEGIN | |
2991 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
2992 | END | |
2993 | ||
2994 | <STATIC> | |
2995 | ||
2996 | import from TempA all; | |
2997 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
2998 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
2999 | ||
3000 | const BERPDU b := -129 | |
3001 | ||
3002 | <TTCN_TC:EXEC> | |
3003 | ||
3004 | if ((enc_DER_PDU(b) == 'C102FF7F'O)and(enc_CER_PDU(b) == 'C102FF7F'O)) {setverdict(pass);} else {setverdict(fail);} | |
3005 | ||
3006 | <RESULT> | |
3007 | ||
3008 | Overall verdict: pass | |
3009 | ||
3010 | <END_TC> | |
3011 | ||
3012 | :exmp. | |
3013 | ||
3014 | .*---------------------------------------------------------------------* | |
3015 | :h3. DER + CER encoding of integer (-129) with APPLICATION TAG, IMPLICIT | |
3016 | .*---------------------------------------------------------------------* | |
3017 | :xmp tab=0. | |
3018 | ||
3019 | <TC - DER + CER encoding of integer (-129) with APPLICATION TAG, IMPLICIT> | |
3020 | ||
3021 | <STATIC:ASN> | |
3022 | ||
3023 | TempA | |
3024 | ||
3025 | DEFINITIONS ::= | |
3026 | BEGIN | |
3027 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
3028 | END | |
3029 | ||
3030 | <STATIC> | |
3031 | ||
3032 | import from TempA all; | |
3033 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
3034 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
3035 | ||
3036 | const BERPDU b := -129 | |
3037 | ||
3038 | <TTCN_TC:EXEC> | |
3039 | ||
3040 | if ((enc_DER_PDU(b) == '4202FF7F'O)and(enc_CER_PDU(b) == '4202FF7F'O)) {setverdict(pass);} else {setverdict(fail);} | |
3041 | ||
3042 | <RESULT> | |
3043 | ||
3044 | Overall verdict: pass | |
3045 | ||
3046 | <END_TC> | |
3047 | ||
3048 | :exmp. | |
3049 | ||
3050 | .*---------------------------------------------------------------------* | |
3051 | :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT | |
3052 | .*---------------------------------------------------------------------* | |
3053 | :xmp tab=0. | |
3054 | ||
3055 | <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT> | |
3056 | ||
3057 | TAG=30 | |
3058 | ||
3059 | <STATIC:ASN> | |
3060 | ||
3061 | TempA | |
3062 | ||
3063 | DEFINITIONS ::= | |
3064 | BEGIN | |
3065 | BERPDU ::= [30] EXPLICIT INTEGER | |
3066 | END | |
3067 | ||
3068 | <STATIC> | |
3069 | ||
3070 | import from TempA all; | |
3071 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
3072 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
3073 | ||
3074 | const BERPDU b := 5 | |
3075 | ||
3076 | <TTCN_TC:EXEC> | |
3077 | ||
3078 | if ((enc_DER_PDU(b) == 'BE03020105'O)and(enc_CER_PDU(b) == 'BE800201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
3079 | ||
3080 | <RESULT> | |
3081 | ||
3082 | Overall verdict: pass | |
3083 | ||
3084 | <END_TC> | |
3085 | ||
3086 | :exmp. | |
3087 | ||
3088 | .*---------------------------------------------------------------------* | |
3089 | :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT | |
3090 | .*---------------------------------------------------------------------* | |
3091 | :xmp tab=0. | |
3092 | ||
3093 | <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT> | |
3094 | ||
3095 | TAG=31 | |
3096 | ||
3097 | <STATIC:ASN> | |
3098 | ||
3099 | TempA | |
3100 | ||
3101 | DEFINITIONS ::= | |
3102 | BEGIN | |
3103 | BERPDU ::= [31] EXPLICIT INTEGER | |
3104 | END | |
3105 | ||
3106 | <STATIC> | |
3107 | ||
3108 | import from TempA all; | |
3109 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
3110 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
3111 | ||
3112 | const BERPDU b := 5 | |
3113 | ||
3114 | <TTCN_TC:EXEC> | |
3115 | ||
3116 | if ((enc_DER_PDU(b) == 'BF1F03020105'O)and(enc_CER_PDU(b) == 'BF1F800201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
3117 | ||
3118 | <RESULT> | |
3119 | ||
3120 | Overall verdict: pass | |
3121 | ||
3122 | <END_TC> | |
3123 | ||
3124 | :exmp. | |
3125 | ||
3126 | .*---------------------------------------------------------------------* | |
3127 | :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT | |
3128 | .*---------------------------------------------------------------------* | |
3129 | :xmp tab=0. | |
3130 | ||
3131 | <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT> | |
3132 | ||
3133 | TAG=127 | |
3134 | ||
3135 | <STATIC:ASN> | |
3136 | ||
3137 | TempA | |
3138 | ||
3139 | DEFINITIONS ::= | |
3140 | BEGIN | |
3141 | BERPDU ::= [127] EXPLICIT INTEGER | |
3142 | END | |
3143 | ||
3144 | <STATIC> | |
3145 | ||
3146 | import from TempA all; | |
3147 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
3148 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
3149 | ||
3150 | const BERPDU b := 5 | |
3151 | ||
3152 | <TTCN_TC:EXEC> | |
3153 | ||
3154 | if ((enc_DER_PDU(b) == 'BF7F03020105'O)and(enc_CER_PDU(b) == 'BF7F800201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
3155 | ||
3156 | <RESULT> | |
3157 | ||
3158 | Overall verdict: pass | |
3159 | ||
3160 | <END_TC> | |
3161 | ||
3162 | :exmp. | |
3163 | ||
3164 | .*---------------------------------------------------------------------* | |
3165 | :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT | |
3166 | .*---------------------------------------------------------------------* | |
3167 | :xmp tab=0. | |
3168 | ||
3169 | <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT> | |
3170 | ||
3171 | TAG=128 | |
3172 | ||
3173 | <STATIC:ASN> | |
3174 | ||
3175 | TempA | |
3176 | ||
3177 | DEFINITIONS ::= | |
3178 | BEGIN | |
3179 | BERPDU ::= [128] EXPLICIT INTEGER | |
3180 | END | |
3181 | ||
3182 | <STATIC> | |
3183 | ||
3184 | import from TempA all; | |
3185 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
3186 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
3187 | ||
3188 | const BERPDU b := 5 | |
3189 | ||
3190 | <TTCN_TC:EXEC> | |
3191 | ||
3192 | if ((enc_DER_PDU(b) == 'BF810003020105'O)and(enc_CER_PDU(b) == 'BF8100800201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
3193 | ||
3194 | <RESULT> | |
3195 | ||
3196 | Overall verdict: pass | |
3197 | ||
3198 | <END_TC> | |
3199 | ||
3200 | :exmp. | |
3201 | ||
3202 | .*---------------------------------------------------------------------* | |
3203 | :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT | |
3204 | .*---------------------------------------------------------------------* | |
3205 | :xmp tab=0. | |
3206 | ||
3207 | <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT> | |
3208 | ||
3209 | TAG=16383 | |
3210 | ||
3211 | <STATIC:ASN> | |
3212 | ||
3213 | TempA | |
3214 | ||
3215 | DEFINITIONS ::= | |
3216 | BEGIN | |
3217 | BERPDU ::= [16383] EXPLICIT INTEGER | |
3218 | END | |
3219 | ||
3220 | <STATIC> | |
3221 | ||
3222 | import from TempA all; | |
3223 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
3224 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
3225 | ||
3226 | const BERPDU b := 5 | |
3227 | ||
3228 | <TTCN_TC:EXEC> | |
3229 | ||
3230 | if ((enc_DER_PDU(b) == 'BFFF7F03020105'O)and(enc_CER_PDU(b) == 'BFFF7F800201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
3231 | ||
3232 | <RESULT> | |
3233 | ||
3234 | Overall verdict: pass | |
3235 | ||
3236 | <END_TC> | |
3237 | ||
3238 | :exmp. | |
3239 | ||
3240 | .*---------------------------------------------------------------------* | |
3241 | :h3. DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT | |
3242 | .*---------------------------------------------------------------------* | |
3243 | :xmp tab=0. | |
3244 | ||
3245 | <TC - DER + CER encoding of integer (5) with Context Specific TAG, EXPLICIT> | |
3246 | ||
3247 | TAG=16384 | |
3248 | ||
3249 | <STATIC:ASN> | |
3250 | ||
3251 | TempA | |
3252 | ||
3253 | DEFINITIONS ::= | |
3254 | BEGIN | |
3255 | BERPDU ::= [16384] EXPLICIT INTEGER | |
3256 | END | |
3257 | ||
3258 | <STATIC> | |
3259 | ||
3260 | import from TempA all; | |
3261 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
3262 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
3263 | ||
3264 | const BERPDU b := 5 | |
3265 | ||
3266 | <TTCN_TC:EXEC> | |
3267 | ||
3268 | if ((enc_DER_PDU(b) == 'BF81800003020105'O)and(enc_CER_PDU(b) == 'BF818000800201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
3269 | ||
3270 | <RESULT> | |
3271 | ||
3272 | Overall verdict: pass | |
3273 | ||
3274 | <END_TC> | |
3275 | ||
3276 | :exmp. | |
3277 | ||
3278 | .*---------------------------------------------------------------------* | |
3279 | :h3. DECODING INTEGER (5), CER+DER | |
3280 | .*---------------------------------------------------------------------* | |
3281 | :xmp tab=0. | |
3282 | ||
3283 | <TC - DECODING INTEGER (5), CER+DER> | |
3284 | ||
3285 | <STATIC:ASN> | |
3286 | ||
3287 | TempA | |
3288 | ||
3289 | DEFINITIONS ::= | |
3290 | BEGIN | |
3291 | BERPDU ::= INTEGER | |
3292 | ||
3293 | myIntegerValue BERPDU ::= 5 | |
3294 | ||
3295 | END | |
3296 | ||
3297 | <STATIC> | |
3298 | ||
3299 | import from TempA all; | |
3300 | ||
3301 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3302 | ||
3303 | ||
3304 | <TTCN_TC:EXEC> | |
3305 | ||
3306 | if (dec_BER_PDU('020105'O) == myIntegerValue) | |
3307 | ||
3308 | ||
3309 | {setverdict(pass);} else {setverdict(fail);} | |
3310 | ||
3311 | ||
3312 | <RESULT> | |
3313 | ||
3314 | Overall verdict: pass | |
3315 | ||
3316 | <END_TC> | |
3317 | ||
3318 | :exmp. | |
3319 | ||
3320 | .*---------------------------------------------------------------------* | |
3321 | :h3. DECODING INTEGER (5), (LENGTH OF LENGTH = 1) | |
3322 | .*---------------------------------------------------------------------* | |
3323 | :xmp tab=0. | |
3324 | ||
3325 | <TC - DECODING INTEGER (5), (LENGTH OF LENGTH = 1)> | |
3326 | ||
3327 | <STATIC:ASN> | |
3328 | ||
3329 | TempA | |
3330 | ||
3331 | DEFINITIONS ::= | |
3332 | BEGIN | |
3333 | BERPDU ::= INTEGER | |
3334 | ||
3335 | myIntegerValue BERPDU ::= 5 | |
3336 | ||
3337 | END | |
3338 | ||
3339 | <STATIC> | |
3340 | ||
3341 | import from TempA all; | |
3342 | ||
3343 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3344 | ||
3345 | ||
3346 | <TTCN_TC:EXEC> | |
3347 | ||
3348 | if (dec_BER_PDU('02810105'O) == myIntegerValue) | |
3349 | ||
3350 | ||
3351 | {setverdict(pass);} else {setverdict(fail);} | |
3352 | ||
3353 | ||
3354 | <RESULT> | |
3355 | ||
3356 | Overall verdict: pass | |
3357 | ||
3358 | <END_TC> | |
3359 | ||
3360 | :exmp. | |
3361 | ||
3362 | .*---------------------------------------------------------------------* | |
3363 | :h3. DECODING INTEGER (5), (LENGTH OF LENGTH = 2) | |
3364 | .*---------------------------------------------------------------------* | |
3365 | :xmp tab=0. | |
3366 | ||
3367 | <TC - DECODING INTEGER (5), (LENGTH OF LENGTH = 2)> | |
3368 | ||
3369 | <STATIC:ASN> | |
3370 | ||
3371 | TempA | |
3372 | ||
3373 | DEFINITIONS ::= | |
3374 | BEGIN | |
3375 | BERPDU ::= INTEGER | |
3376 | ||
3377 | myIntegerValue BERPDU ::= 5 | |
3378 | ||
3379 | END | |
3380 | ||
3381 | <STATIC> | |
3382 | ||
3383 | import from TempA all; | |
3384 | ||
3385 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3386 | ||
3387 | ||
3388 | <TTCN_TC:EXEC> | |
3389 | ||
3390 | if (dec_BER_PDU('0282000105'O) == myIntegerValue) | |
3391 | ||
3392 | ||
3393 | {setverdict(pass);} else {setverdict(fail);} | |
3394 | ||
3395 | ||
3396 | <RESULT> | |
3397 | ||
3398 | Overall verdict: pass | |
3399 | ||
3400 | <END_TC> | |
3401 | ||
3402 | :exmp. | |
3403 | ||
3404 | .*---------------------------------------------------------------------* | |
3405 | :h3. DECODING [0] EXPLICIT INTEGER (5), DER | |
3406 | .*---------------------------------------------------------------------* | |
3407 | :xmp tab=0. | |
3408 | ||
3409 | <TC - DECODING [0] EXPLICIT INTEGER (5), DER> | |
3410 | ||
3411 | <STATIC:ASN> | |
3412 | ||
3413 | TempA | |
3414 | ||
3415 | DEFINITIONS ::= | |
3416 | BEGIN | |
3417 | BERPDU ::= [0] EXPLICIT INTEGER | |
3418 | ||
3419 | myIntegerValue BERPDU ::= 5 | |
3420 | ||
3421 | END | |
3422 | ||
3423 | <STATIC> | |
3424 | ||
3425 | import from TempA all; | |
3426 | ||
3427 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3428 | ||
3429 | ||
3430 | <TTCN_TC:EXEC> | |
3431 | ||
3432 | if (dec_BER_PDU('A003020105'O) == myIntegerValue) | |
3433 | ||
3434 | ||
3435 | {setverdict(pass);} else {setverdict(fail);} | |
3436 | ||
3437 | ||
3438 | <RESULT> | |
3439 | ||
3440 | Overall verdict: pass | |
3441 | ||
3442 | <END_TC> | |
3443 | ||
3444 | :exmp. | |
3445 | ||
3446 | .*---------------------------------------------------------------------* | |
3447 | :h3. DECODING [0] EXPLICIT INTEGER (5), CER | |
3448 | .*---------------------------------------------------------------------* | |
3449 | :xmp tab=0. | |
3450 | ||
3451 | <TC - DECODING [0] EXPLICIT INTEGER (5), CER> | |
3452 | ||
3453 | <STATIC:ASN> | |
3454 | ||
3455 | TempA | |
3456 | ||
3457 | DEFINITIONS ::= | |
3458 | BEGIN | |
3459 | BERPDU ::= [0] EXPLICIT INTEGER | |
3460 | ||
3461 | myIntegerValue BERPDU ::= 5 | |
3462 | ||
3463 | END | |
3464 | ||
3465 | <STATIC> | |
3466 | ||
3467 | import from TempA all; | |
3468 | ||
3469 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3470 | ||
3471 | ||
3472 | <TTCN_TC:EXEC> | |
3473 | ||
3474 | if (dec_BER_PDU('A0800201050000'O) == myIntegerValue) | |
3475 | ||
3476 | ||
3477 | {setverdict(pass);} else {setverdict(fail);} | |
3478 | ||
3479 | ||
3480 | <RESULT> | |
3481 | ||
3482 | Overall verdict: pass | |
3483 | ||
3484 | <END_TC> | |
3485 | ||
3486 | :exmp. | |
3487 | ||
3488 | .*---------------------------------------------------------------------* | |
3489 | :h3. DECODING [0] EXPLICIT INTEGER (5), Short form - long form | |
3490 | .*---------------------------------------------------------------------* | |
3491 | :xmp tab=0. | |
3492 | ||
3493 | <TC - DECODING [0] EXPLICIT INTEGER (5), Short form - long form> | |
3494 | ||
3495 | <STATIC:ASN> | |
3496 | ||
3497 | TempA | |
3498 | ||
3499 | DEFINITIONS ::= | |
3500 | BEGIN | |
3501 | BERPDU ::= [0] EXPLICIT INTEGER | |
3502 | ||
3503 | myIntegerValue BERPDU ::= 5 | |
3504 | ||
3505 | END | |
3506 | ||
3507 | <STATIC> | |
3508 | ||
3509 | import from TempA all; | |
3510 | ||
3511 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3512 | ||
3513 | ||
3514 | <TTCN_TC:EXEC> | |
3515 | ||
3516 | if (dec_BER_PDU('A003020105'O) == myIntegerValue) | |
3517 | ||
3518 | ||
3519 | {setverdict(pass);} else {setverdict(fail);} | |
3520 | ||
3521 | ||
3522 | <RESULT> | |
3523 | ||
3524 | Overall verdict: pass | |
3525 | ||
3526 | <END_TC> | |
3527 | ||
3528 | :exmp. | |
3529 | ||
3530 | .*---------------------------------------------------------------------* | |
3531 | :h3. DECODING [0] EXPLICIT INTEGER (5), Long form - short form | |
3532 | .*---------------------------------------------------------------------* | |
3533 | :xmp tab=0. | |
3534 | ||
3535 | <TC - DECODING [0] EXPLICIT INTEGER (5), Long form - short form> | |
3536 | ||
3537 | <STATIC:ASN> | |
3538 | ||
3539 | TempA | |
3540 | ||
3541 | DEFINITIONS ::= | |
3542 | BEGIN | |
3543 | BERPDU ::= [0] EXPLICIT INTEGER | |
3544 | ||
3545 | myIntegerValue BERPDU ::= 5 | |
3546 | ||
3547 | END | |
3548 | ||
3549 | <STATIC> | |
3550 | ||
3551 | import from TempA all; | |
3552 | ||
3553 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3554 | ||
3555 | ||
3556 | <TTCN_TC:EXEC> | |
3557 | ||
3558 | if (dec_BER_PDU('A08103020105'O) == myIntegerValue) | |
3559 | ||
3560 | ||
3561 | {setverdict(pass);} else {setverdict(fail);} | |
3562 | ||
3563 | ||
3564 | <RESULT> | |
3565 | ||
3566 | Overall verdict: pass | |
3567 | ||
3568 | <END_TC> | |
3569 | ||
3570 | :exmp. | |
3571 | ||
3572 | .*---------------------------------------------------------------------* | |
3573 | :h3. DECODING [0] EXPLICIT INTEGER (5), Long form Long form | |
3574 | .*---------------------------------------------------------------------* | |
3575 | :xmp tab=0. | |
3576 | ||
3577 | <TC - DECODING [0] EXPLICIT INTEGER (5), Long form Long form> | |
3578 | ||
3579 | <STATIC:ASN> | |
3580 | ||
3581 | TempA | |
3582 | ||
3583 | DEFINITIONS ::= | |
3584 | BEGIN | |
3585 | BERPDU ::= [0] EXPLICIT INTEGER | |
3586 | ||
3587 | myIntegerValue BERPDU ::= 5 | |
3588 | ||
3589 | END | |
3590 | ||
3591 | <STATIC> | |
3592 | ||
3593 | import from TempA all; | |
3594 | ||
3595 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3596 | ||
3597 | ||
3598 | <TTCN_TC:EXEC> | |
3599 | ||
3600 | if (dec_BER_PDU('A0810402810105'O) == myIntegerValue) | |
3601 | ||
3602 | ||
3603 | {setverdict(pass);} else {setverdict(fail);} | |
3604 | ||
3605 | ||
3606 | <RESULT> | |
3607 | ||
3608 | Overall verdict: pass | |
3609 | ||
3610 | <END_TC> | |
3611 | ||
3612 | :exmp. | |
3613 | ||
3614 | .*---------------------------------------------------------------------* | |
3615 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Short form - Short form, DER | |
3616 | .*---------------------------------------------------------------------* | |
3617 | :xmp tab=0. | |
3618 | ||
3619 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Short form - Short form, DER> | |
3620 | ||
3621 | <STATIC:ASN> | |
3622 | ||
3623 | TempA | |
3624 | ||
3625 | DEFINITIONS ::= | |
3626 | BEGIN | |
3627 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
3628 | ||
3629 | myIntegerValue BERPDU ::= 5 | |
3630 | ||
3631 | END | |
3632 | ||
3633 | <STATIC> | |
3634 | ||
3635 | import from TempA all; | |
3636 | ||
3637 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3638 | ||
3639 | ||
3640 | <TTCN_TC:EXEC> | |
3641 | ||
3642 | if (dec_BER_PDU('E103020105'O) == myIntegerValue) | |
3643 | ||
3644 | ||
3645 | {setverdict(pass);} else {setverdict(fail);} | |
3646 | ||
3647 | ||
3648 | <RESULT> | |
3649 | ||
3650 | Overall verdict: pass | |
3651 | ||
3652 | <END_TC> | |
3653 | ||
3654 | :exmp. | |
3655 | ||
3656 | .*---------------------------------------------------------------------* | |
3657 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Short form - long form | |
3658 | .*---------------------------------------------------------------------* | |
3659 | :xmp tab=0. | |
3660 | ||
3661 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Short form - long form> | |
3662 | ||
3663 | <STATIC:ASN> | |
3664 | ||
3665 | TempA | |
3666 | ||
3667 | DEFINITIONS ::= | |
3668 | BEGIN | |
3669 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
3670 | ||
3671 | myIntegerValue BERPDU ::= 5 | |
3672 | ||
3673 | END | |
3674 | ||
3675 | <STATIC> | |
3676 | ||
3677 | import from TempA all; | |
3678 | ||
3679 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3680 | ||
3681 | ||
3682 | <TTCN_TC:EXEC> | |
3683 | ||
3684 | if (dec_BER_PDU('E10402810105'O) == myIntegerValue) | |
3685 | ||
3686 | ||
3687 | {setverdict(pass);} else {setverdict(fail);} | |
3688 | ||
3689 | ||
3690 | <RESULT> | |
3691 | ||
3692 | Overall verdict: pass | |
3693 | ||
3694 | <END_TC> | |
3695 | ||
3696 | :exmp. | |
3697 | ||
3698 | .*---------------------------------------------------------------------* | |
3699 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Long form - short form | |
3700 | .*---------------------------------------------------------------------* | |
3701 | :xmp tab=0. | |
3702 | ||
3703 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Long form - short form> | |
3704 | ||
3705 | <STATIC:ASN> | |
3706 | ||
3707 | TempA | |
3708 | ||
3709 | DEFINITIONS ::= | |
3710 | BEGIN | |
3711 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
3712 | ||
3713 | myIntegerValue BERPDU ::= 5 | |
3714 | ||
3715 | END | |
3716 | ||
3717 | <STATIC> | |
3718 | ||
3719 | import from TempA all; | |
3720 | ||
3721 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3722 | ||
3723 | ||
3724 | <TTCN_TC:EXEC> | |
3725 | ||
3726 | if (dec_BER_PDU('E18103020105'O) == myIntegerValue) | |
3727 | ||
3728 | ||
3729 | {setverdict(pass);} else {setverdict(fail);} | |
3730 | ||
3731 | ||
3732 | <RESULT> | |
3733 | ||
3734 | Overall verdict: pass | |
3735 | ||
3736 | <END_TC> | |
3737 | ||
3738 | :exmp. | |
3739 | ||
3740 | .*---------------------------------------------------------------------* | |
3741 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Long form Long form | |
3742 | .*---------------------------------------------------------------------* | |
3743 | :xmp tab=0. | |
3744 | ||
3745 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5), Long form Long form> | |
3746 | ||
3747 | <STATIC:ASN> | |
3748 | ||
3749 | TempA | |
3750 | ||
3751 | DEFINITIONS ::= | |
3752 | BEGIN | |
3753 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
3754 | ||
3755 | myIntegerValue BERPDU ::= 5 | |
3756 | ||
3757 | END | |
3758 | ||
3759 | <STATIC> | |
3760 | ||
3761 | import from TempA all; | |
3762 | ||
3763 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3764 | ||
3765 | ||
3766 | <TTCN_TC:EXEC> | |
3767 | ||
3768 | if (dec_BER_PDU('E1810402810105'O) == myIntegerValue) | |
3769 | ||
3770 | ||
3771 | {setverdict(pass);} else {setverdict(fail);} | |
3772 | ||
3773 | ||
3774 | <RESULT> | |
3775 | ||
3776 | Overall verdict: pass | |
3777 | ||
3778 | <END_TC> | |
3779 | ||
3780 | :exmp. | |
3781 | ||
3782 | .*---------------------------------------------------------------------* | |
3783 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (5),Indefinite form,CER | |
3784 | .*---------------------------------------------------------------------* | |
3785 | :xmp tab=0. | |
3786 | ||
3787 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (5),Indefinite form,CER> | |
3788 | ||
3789 | <STATIC:ASN> | |
3790 | ||
3791 | TempA | |
3792 | ||
3793 | DEFINITIONS ::= | |
3794 | BEGIN | |
3795 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
3796 | ||
3797 | myIntegerValue BERPDU ::= 5 | |
3798 | ||
3799 | END | |
3800 | ||
3801 | <STATIC> | |
3802 | ||
3803 | import from TempA all; | |
3804 | ||
3805 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3806 | ||
3807 | ||
3808 | <TTCN_TC:EXEC> | |
3809 | ||
3810 | if (dec_BER_PDU('E1800201050000'O) == myIntegerValue) | |
3811 | ||
3812 | ||
3813 | {setverdict(pass);} else {setverdict(fail);} | |
3814 | ||
3815 | ||
3816 | <RESULT> | |
3817 | ||
3818 | Overall verdict: pass | |
3819 | ||
3820 | <END_TC> | |
3821 | ||
3822 | :exmp. | |
3823 | ||
3824 | .*---------------------------------------------------------------------* | |
3825 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Short form - Short form, DER | |
3826 | .*---------------------------------------------------------------------* | |
3827 | :xmp tab=0. | |
3828 | ||
3829 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Short form - Short form, DER> | |
3830 | ||
3831 | <STATIC:ASN> | |
3832 | ||
3833 | TempA | |
3834 | ||
3835 | DEFINITIONS ::= | |
3836 | BEGIN | |
3837 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
3838 | ||
3839 | myIntegerValue BERPDU ::= 5 | |
3840 | ||
3841 | END | |
3842 | ||
3843 | <STATIC> | |
3844 | ||
3845 | import from TempA all; | |
3846 | ||
3847 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3848 | ||
3849 | ||
3850 | <TTCN_TC:EXEC> | |
3851 | ||
3852 | if (dec_BER_PDU('6203020105'O) == myIntegerValue) | |
3853 | ||
3854 | ||
3855 | {setverdict(pass);} else {setverdict(fail);} | |
3856 | ||
3857 | ||
3858 | <RESULT> | |
3859 | ||
3860 | Overall verdict: pass | |
3861 | ||
3862 | <END_TC> | |
3863 | ||
3864 | :exmp. | |
3865 | ||
3866 | .*---------------------------------------------------------------------* | |
3867 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Short form - long form | |
3868 | .*---------------------------------------------------------------------* | |
3869 | :xmp tab=0. | |
3870 | ||
3871 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Short form - long form> | |
3872 | ||
3873 | <STATIC:ASN> | |
3874 | ||
3875 | TempA | |
3876 | ||
3877 | DEFINITIONS ::= | |
3878 | BEGIN | |
3879 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
3880 | ||
3881 | myIntegerValue BERPDU ::= 5 | |
3882 | ||
3883 | END | |
3884 | ||
3885 | <STATIC> | |
3886 | ||
3887 | import from TempA all; | |
3888 | ||
3889 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3890 | ||
3891 | ||
3892 | <TTCN_TC:EXEC> | |
3893 | ||
3894 | if (dec_BER_PDU('620402810105'O) == myIntegerValue) | |
3895 | ||
3896 | ||
3897 | {setverdict(pass);} else {setverdict(fail);} | |
3898 | ||
3899 | ||
3900 | <RESULT> | |
3901 | ||
3902 | Overall verdict: pass | |
3903 | ||
3904 | <END_TC> | |
3905 | ||
3906 | :exmp. | |
3907 | ||
3908 | .*---------------------------------------------------------------------* | |
3909 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Long form - short form | |
3910 | .*---------------------------------------------------------------------* | |
3911 | :xmp tab=0. | |
3912 | ||
3913 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Long form - short form> | |
3914 | ||
3915 | <STATIC:ASN> | |
3916 | ||
3917 | TempA | |
3918 | ||
3919 | DEFINITIONS ::= | |
3920 | BEGIN | |
3921 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
3922 | ||
3923 | myIntegerValue BERPDU ::= 5 | |
3924 | ||
3925 | END | |
3926 | ||
3927 | <STATIC> | |
3928 | ||
3929 | import from TempA all; | |
3930 | ||
3931 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3932 | ||
3933 | ||
3934 | <TTCN_TC:EXEC> | |
3935 | ||
3936 | if (dec_BER_PDU('628103020105'O) == myIntegerValue) | |
3937 | ||
3938 | ||
3939 | {setverdict(pass);} else {setverdict(fail);} | |
3940 | ||
3941 | ||
3942 | <RESULT> | |
3943 | ||
3944 | Overall verdict: pass | |
3945 | ||
3946 | <END_TC> | |
3947 | ||
3948 | :exmp. | |
3949 | ||
3950 | .*---------------------------------------------------------------------* | |
3951 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Long form Long form | |
3952 | .*---------------------------------------------------------------------* | |
3953 | :xmp tab=0. | |
3954 | ||
3955 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5), Long form Long form> | |
3956 | ||
3957 | <STATIC:ASN> | |
3958 | ||
3959 | TempA | |
3960 | ||
3961 | DEFINITIONS ::= | |
3962 | BEGIN | |
3963 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
3964 | ||
3965 | myIntegerValue BERPDU ::= 5 | |
3966 | ||
3967 | END | |
3968 | ||
3969 | <STATIC> | |
3970 | ||
3971 | import from TempA all; | |
3972 | ||
3973 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
3974 | ||
3975 | ||
3976 | <TTCN_TC:EXEC> | |
3977 | ||
3978 | if (dec_BER_PDU('62810402810105'O) == myIntegerValue) | |
3979 | ||
3980 | ||
3981 | {setverdict(pass);} else {setverdict(fail);} | |
3982 | ||
3983 | ||
3984 | <RESULT> | |
3985 | ||
3986 | Overall verdict: pass | |
3987 | ||
3988 | <END_TC> | |
3989 | ||
3990 | :exmp. | |
3991 | ||
3992 | .*---------------------------------------------------------------------* | |
3993 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (5),Indefinite form,CER | |
3994 | .*---------------------------------------------------------------------* | |
3995 | :xmp tab=0. | |
3996 | ||
3997 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (5),Indefinite form,CER> | |
3998 | ||
3999 | <STATIC:ASN> | |
4000 | ||
4001 | TempA | |
4002 | ||
4003 | DEFINITIONS ::= | |
4004 | BEGIN | |
4005 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
4006 | ||
4007 | myIntegerValue BERPDU ::= 5 | |
4008 | ||
4009 | END | |
4010 | ||
4011 | <STATIC> | |
4012 | ||
4013 | import from TempA all; | |
4014 | ||
4015 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4016 | ||
4017 | ||
4018 | <TTCN_TC:EXEC> | |
4019 | ||
4020 | if (dec_BER_PDU('62800201050000'O) == myIntegerValue) | |
4021 | ||
4022 | ||
4023 | {setverdict(pass);} else {setverdict(fail);} | |
4024 | ||
4025 | ||
4026 | <RESULT> | |
4027 | ||
4028 | Overall verdict: pass | |
4029 | ||
4030 | <END_TC> | |
4031 | ||
4032 | :exmp. | |
4033 | ||
4034 | .*---------------------------------------------------------------------* | |
4035 | :h3. DECODING [0] IMPLICIT INTEGER (5),Short form CER,DER | |
4036 | .*---------------------------------------------------------------------* | |
4037 | :xmp tab=0. | |
4038 | ||
4039 | <TC - DECODING [0] IMPLICIT INTEGER (5),Short form CER,DER> | |
4040 | ||
4041 | <STATIC:ASN> | |
4042 | ||
4043 | TempA | |
4044 | ||
4045 | DEFINITIONS ::= | |
4046 | BEGIN | |
4047 | BERPDU ::= [0] IMPLICIT INTEGER | |
4048 | ||
4049 | myIntegerValue BERPDU ::= 5 | |
4050 | ||
4051 | END | |
4052 | ||
4053 | <STATIC> | |
4054 | ||
4055 | import from TempA all; | |
4056 | ||
4057 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4058 | ||
4059 | ||
4060 | <TTCN_TC:EXEC> | |
4061 | ||
4062 | if (dec_BER_PDU('800105'O) == myIntegerValue) | |
4063 | ||
4064 | ||
4065 | {setverdict(pass);} else {setverdict(fail);} | |
4066 | ||
4067 | ||
4068 | <RESULT> | |
4069 | ||
4070 | Overall verdict: pass | |
4071 | ||
4072 | <END_TC> | |
4073 | ||
4074 | :exmp. | |
4075 | ||
4076 | .*---------------------------------------------------------------------* | |
4077 | :h3. DECODING [0] IMPLICIT INTEGER (5),Long form | |
4078 | .*---------------------------------------------------------------------* | |
4079 | :xmp tab=0. | |
4080 | ||
4081 | <TC - DECODING [0] IMPLICIT INTEGER (5),Long form> | |
4082 | ||
4083 | <STATIC:ASN> | |
4084 | ||
4085 | TempA | |
4086 | ||
4087 | DEFINITIONS ::= | |
4088 | BEGIN | |
4089 | BERPDU ::= [0] IMPLICIT INTEGER | |
4090 | ||
4091 | myIntegerValue BERPDU ::= 5 | |
4092 | ||
4093 | END | |
4094 | ||
4095 | <STATIC> | |
4096 | ||
4097 | import from TempA all; | |
4098 | ||
4099 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4100 | ||
4101 | ||
4102 | <TTCN_TC:EXEC> | |
4103 | ||
4104 | if (dec_BER_PDU('80810105'O) == myIntegerValue) | |
4105 | ||
4106 | ||
4107 | {setverdict(pass);} else {setverdict(fail);} | |
4108 | ||
4109 | ||
4110 | <RESULT> | |
4111 | ||
4112 | Overall verdict: pass | |
4113 | ||
4114 | <END_TC> | |
4115 | ||
4116 | :exmp. | |
4117 | ||
4118 | .*---------------------------------------------------------------------* | |
4119 | :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (5),Short form CER,DER | |
4120 | .*---------------------------------------------------------------------* | |
4121 | :xmp tab=0. | |
4122 | ||
4123 | <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (5),Short form CER,DER> | |
4124 | ||
4125 | <STATIC:ASN> | |
4126 | ||
4127 | TempA | |
4128 | ||
4129 | DEFINITIONS ::= | |
4130 | BEGIN | |
4131 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
4132 | ||
4133 | myIntegerValue BERPDU ::= 5 | |
4134 | ||
4135 | END | |
4136 | ||
4137 | <STATIC> | |
4138 | ||
4139 | import from TempA all; | |
4140 | ||
4141 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4142 | ||
4143 | ||
4144 | <TTCN_TC:EXEC> | |
4145 | ||
4146 | if (dec_BER_PDU('C10105'O) == myIntegerValue) | |
4147 | ||
4148 | ||
4149 | {setverdict(pass);} else {setverdict(fail);} | |
4150 | ||
4151 | ||
4152 | <RESULT> | |
4153 | ||
4154 | Overall verdict: pass | |
4155 | ||
4156 | <END_TC> | |
4157 | ||
4158 | :exmp. | |
4159 | ||
4160 | .*---------------------------------------------------------------------* | |
4161 | :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (5),Long form | |
4162 | .*---------------------------------------------------------------------* | |
4163 | :xmp tab=0. | |
4164 | ||
4165 | <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (5),Long form> | |
4166 | ||
4167 | <STATIC:ASN> | |
4168 | ||
4169 | TempA | |
4170 | ||
4171 | DEFINITIONS ::= | |
4172 | BEGIN | |
4173 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
4174 | ||
4175 | myIntegerValue BERPDU ::= 5 | |
4176 | ||
4177 | END | |
4178 | ||
4179 | <STATIC> | |
4180 | ||
4181 | import from TempA all; | |
4182 | ||
4183 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4184 | ||
4185 | ||
4186 | <TTCN_TC:EXEC> | |
4187 | ||
4188 | if (dec_BER_PDU('C1810105'O) == myIntegerValue) | |
4189 | ||
4190 | ||
4191 | {setverdict(pass);} else {setverdict(fail);} | |
4192 | ||
4193 | ||
4194 | <RESULT> | |
4195 | ||
4196 | Overall verdict: pass | |
4197 | ||
4198 | <END_TC> | |
4199 | ||
4200 | :exmp. | |
4201 | ||
4202 | .*---------------------------------------------------------------------* | |
4203 | :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (5),Short form CER,DER | |
4204 | .*---------------------------------------------------------------------* | |
4205 | :xmp tab=0. | |
4206 | ||
4207 | <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (5),Short form CER,DER> | |
4208 | ||
4209 | <STATIC:ASN> | |
4210 | ||
4211 | TempA | |
4212 | ||
4213 | DEFINITIONS ::= | |
4214 | BEGIN | |
4215 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
4216 | ||
4217 | myIntegerValue BERPDU ::= 5 | |
4218 | ||
4219 | END | |
4220 | ||
4221 | <STATIC> | |
4222 | ||
4223 | import from TempA all; | |
4224 | ||
4225 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4226 | ||
4227 | ||
4228 | <TTCN_TC:EXEC> | |
4229 | ||
4230 | if (dec_BER_PDU('420105'O) == myIntegerValue) | |
4231 | ||
4232 | ||
4233 | {setverdict(pass);} else {setverdict(fail);} | |
4234 | ||
4235 | ||
4236 | <RESULT> | |
4237 | ||
4238 | Overall verdict: pass | |
4239 | ||
4240 | <END_TC> | |
4241 | ||
4242 | :exmp. | |
4243 | ||
4244 | .*---------------------------------------------------------------------* | |
4245 | :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (5),Long form | |
4246 | .*---------------------------------------------------------------------* | |
4247 | :xmp tab=0. | |
4248 | ||
4249 | <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (5),Long form> | |
4250 | ||
4251 | <STATIC:ASN> | |
4252 | ||
4253 | TempA | |
4254 | ||
4255 | DEFINITIONS ::= | |
4256 | BEGIN | |
4257 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
4258 | ||
4259 | myIntegerValue BERPDU ::= 5 | |
4260 | ||
4261 | END | |
4262 | ||
4263 | <STATIC> | |
4264 | ||
4265 | import from TempA all; | |
4266 | ||
4267 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4268 | ||
4269 | ||
4270 | <TTCN_TC:EXEC> | |
4271 | ||
4272 | if (dec_BER_PDU('42810105'O) == myIntegerValue) | |
4273 | ||
4274 | ||
4275 | {setverdict(pass);} else {setverdict(fail);} | |
4276 | ||
4277 | ||
4278 | <RESULT> | |
4279 | ||
4280 | Overall verdict: pass | |
4281 | ||
4282 | <END_TC> | |
4283 | ||
4284 | :exmp. | |
4285 | ||
4286 | .*---------------------------------------------------------------------* | |
4287 | :h3. DECODING INTEGER (0), CER+DER | |
4288 | .*---------------------------------------------------------------------* | |
4289 | :xmp tab=0. | |
4290 | ||
4291 | <TC - DECODING INTEGER (0), CER+DER> | |
4292 | ||
4293 | <STATIC:ASN> | |
4294 | ||
4295 | TempA | |
4296 | ||
4297 | DEFINITIONS ::= | |
4298 | BEGIN | |
4299 | BERPDU ::= INTEGER | |
4300 | ||
4301 | myIntegerValue BERPDU ::= 0 | |
4302 | ||
4303 | END | |
4304 | ||
4305 | <STATIC> | |
4306 | ||
4307 | import from TempA all; | |
4308 | ||
4309 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4310 | ||
4311 | ||
4312 | <TTCN_TC:EXEC> | |
4313 | ||
4314 | if (dec_BER_PDU('020100'O) == myIntegerValue) | |
4315 | ||
4316 | ||
4317 | {setverdict(pass);} else {setverdict(fail);} | |
4318 | ||
4319 | ||
4320 | <RESULT> | |
4321 | ||
4322 | Overall verdict: pass | |
4323 | ||
4324 | <END_TC> | |
4325 | ||
4326 | :exmp. | |
4327 | ||
4328 | .*---------------------------------------------------------------------* | |
4329 | :h3. DECODING INTEGER (0), (LENGTH OF LENGTH = 1) | |
4330 | .*---------------------------------------------------------------------* | |
4331 | :xmp tab=0. | |
4332 | ||
4333 | <TC - DECODING INTEGER (0), (LENGTH OF LENGTH = 1)> | |
4334 | ||
4335 | <STATIC:ASN> | |
4336 | ||
4337 | TempA | |
4338 | ||
4339 | DEFINITIONS ::= | |
4340 | BEGIN | |
4341 | BERPDU ::= INTEGER | |
4342 | ||
4343 | myIntegerValue BERPDU ::= 0 | |
4344 | ||
4345 | END | |
4346 | ||
4347 | <STATIC> | |
4348 | ||
4349 | import from TempA all; | |
4350 | ||
4351 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4352 | ||
4353 | ||
4354 | <TTCN_TC:EXEC> | |
4355 | ||
4356 | if (dec_BER_PDU('02810100'O) == myIntegerValue) | |
4357 | ||
4358 | ||
4359 | {setverdict(pass);} else {setverdict(fail);} | |
4360 | ||
4361 | ||
4362 | <RESULT> | |
4363 | ||
4364 | Overall verdict: pass | |
4365 | ||
4366 | <END_TC> | |
4367 | ||
4368 | :exmp. | |
4369 | ||
4370 | .*---------------------------------------------------------------------* | |
4371 | :h3. DECODING INTEGER (0), (LENGTH OF LENGTH = 2) | |
4372 | .*---------------------------------------------------------------------* | |
4373 | :xmp tab=0. | |
4374 | ||
4375 | <TC - DECODING INTEGER (0), (LENGTH OF LENGTH = 2)> | |
4376 | ||
4377 | <STATIC:ASN> | |
4378 | ||
4379 | TempA | |
4380 | ||
4381 | DEFINITIONS ::= | |
4382 | BEGIN | |
4383 | BERPDU ::= INTEGER | |
4384 | ||
4385 | myIntegerValue BERPDU ::= 0 | |
4386 | ||
4387 | END | |
4388 | ||
4389 | <STATIC> | |
4390 | ||
4391 | import from TempA all; | |
4392 | ||
4393 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4394 | ||
4395 | ||
4396 | <TTCN_TC:EXEC> | |
4397 | ||
4398 | if (dec_BER_PDU('0282000100'O) == myIntegerValue) | |
4399 | ||
4400 | ||
4401 | {setverdict(pass);} else {setverdict(fail);} | |
4402 | ||
4403 | ||
4404 | <RESULT> | |
4405 | ||
4406 | Overall verdict: pass | |
4407 | ||
4408 | <END_TC> | |
4409 | ||
4410 | :exmp. | |
4411 | ||
4412 | .*---------------------------------------------------------------------* | |
4413 | :h3. DECODING [0] EXPLICIT INTEGER (0), DER | |
4414 | .*---------------------------------------------------------------------* | |
4415 | :xmp tab=0. | |
4416 | ||
4417 | <TC - DECODING [0] EXPLICIT INTEGER (0), DER> | |
4418 | ||
4419 | <STATIC:ASN> | |
4420 | ||
4421 | TempA | |
4422 | ||
4423 | DEFINITIONS ::= | |
4424 | BEGIN | |
4425 | BERPDU ::= [0] EXPLICIT INTEGER | |
4426 | ||
4427 | myIntegerValue BERPDU ::= 0 | |
4428 | ||
4429 | END | |
4430 | ||
4431 | <STATIC> | |
4432 | ||
4433 | import from TempA all; | |
4434 | ||
4435 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4436 | ||
4437 | ||
4438 | <TTCN_TC:EXEC> | |
4439 | ||
4440 | if (dec_BER_PDU('A003020100'O) == myIntegerValue) | |
4441 | ||
4442 | ||
4443 | {setverdict(pass);} else {setverdict(fail);} | |
4444 | ||
4445 | ||
4446 | <RESULT> | |
4447 | ||
4448 | Overall verdict: pass | |
4449 | ||
4450 | <END_TC> | |
4451 | ||
4452 | :exmp. | |
4453 | ||
4454 | .*---------------------------------------------------------------------* | |
4455 | :h3. DECODING [0] EXPLICIT INTEGER (0), CER | |
4456 | .*---------------------------------------------------------------------* | |
4457 | :xmp tab=0. | |
4458 | ||
4459 | <TC - DECODING [0] EXPLICIT INTEGER (0), CER> | |
4460 | ||
4461 | <STATIC:ASN> | |
4462 | ||
4463 | TempA | |
4464 | ||
4465 | DEFINITIONS ::= | |
4466 | BEGIN | |
4467 | BERPDU ::= [0] EXPLICIT INTEGER | |
4468 | ||
4469 | myIntegerValue BERPDU ::= 0 | |
4470 | ||
4471 | END | |
4472 | ||
4473 | <STATIC> | |
4474 | ||
4475 | import from TempA all; | |
4476 | ||
4477 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4478 | ||
4479 | ||
4480 | <TTCN_TC:EXEC> | |
4481 | ||
4482 | if (dec_BER_PDU('A0800201000000'O) == myIntegerValue) | |
4483 | ||
4484 | ||
4485 | {setverdict(pass);} else {setverdict(fail);} | |
4486 | ||
4487 | ||
4488 | <RESULT> | |
4489 | ||
4490 | Overall verdict: pass | |
4491 | ||
4492 | <END_TC> | |
4493 | ||
4494 | :exmp. | |
4495 | ||
4496 | .*---------------------------------------------------------------------* | |
4497 | :h3. DECODING [0] EXPLICIT INTEGER (0), Short form - long form | |
4498 | .*---------------------------------------------------------------------* | |
4499 | :xmp tab=0. | |
4500 | ||
4501 | <TC - DECODING [0] EXPLICIT INTEGER (0), Short form - long form> | |
4502 | ||
4503 | <STATIC:ASN> | |
4504 | ||
4505 | TempA | |
4506 | ||
4507 | DEFINITIONS ::= | |
4508 | BEGIN | |
4509 | BERPDU ::= [0] EXPLICIT INTEGER | |
4510 | ||
4511 | myIntegerValue BERPDU ::= 0 | |
4512 | ||
4513 | END | |
4514 | ||
4515 | <STATIC> | |
4516 | ||
4517 | import from TempA all; | |
4518 | ||
4519 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4520 | ||
4521 | ||
4522 | <TTCN_TC:EXEC> | |
4523 | ||
4524 | if (dec_BER_PDU('A003020100'O) == myIntegerValue) | |
4525 | ||
4526 | ||
4527 | {setverdict(pass);} else {setverdict(fail);} | |
4528 | ||
4529 | ||
4530 | <RESULT> | |
4531 | ||
4532 | Overall verdict: pass | |
4533 | ||
4534 | <END_TC> | |
4535 | ||
4536 | :exmp. | |
4537 | ||
4538 | .*---------------------------------------------------------------------* | |
4539 | :h3. DECODING [0] EXPLICIT INTEGER (0), Long form - short form | |
4540 | .*---------------------------------------------------------------------* | |
4541 | :xmp tab=0. | |
4542 | ||
4543 | <TC - DECODING [0] EXPLICIT INTEGER (0), Long form - short form> | |
4544 | ||
4545 | <STATIC:ASN> | |
4546 | ||
4547 | TempA | |
4548 | ||
4549 | DEFINITIONS ::= | |
4550 | BEGIN | |
4551 | BERPDU ::= [0] EXPLICIT INTEGER | |
4552 | ||
4553 | myIntegerValue BERPDU ::= 0 | |
4554 | ||
4555 | END | |
4556 | ||
4557 | <STATIC> | |
4558 | ||
4559 | import from TempA all; | |
4560 | ||
4561 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4562 | ||
4563 | ||
4564 | <TTCN_TC:EXEC> | |
4565 | ||
4566 | if (dec_BER_PDU('A08103020100'O) == myIntegerValue) | |
4567 | ||
4568 | ||
4569 | {setverdict(pass);} else {setverdict(fail);} | |
4570 | ||
4571 | ||
4572 | <RESULT> | |
4573 | ||
4574 | Overall verdict: pass | |
4575 | ||
4576 | <END_TC> | |
4577 | ||
4578 | :exmp. | |
4579 | ||
4580 | .*---------------------------------------------------------------------* | |
4581 | :h3. DECODING [0] EXPLICIT INTEGER (0), Long form Long form | |
4582 | .*---------------------------------------------------------------------* | |
4583 | :xmp tab=0. | |
4584 | ||
4585 | <TC - DECODING [0] EXPLICIT INTEGER (0), Long form Long form> | |
4586 | ||
4587 | <STATIC:ASN> | |
4588 | ||
4589 | TempA | |
4590 | ||
4591 | DEFINITIONS ::= | |
4592 | BEGIN | |
4593 | BERPDU ::= [0] EXPLICIT INTEGER | |
4594 | ||
4595 | myIntegerValue BERPDU ::= 0 | |
4596 | ||
4597 | END | |
4598 | ||
4599 | <STATIC> | |
4600 | ||
4601 | import from TempA all; | |
4602 | ||
4603 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4604 | ||
4605 | ||
4606 | <TTCN_TC:EXEC> | |
4607 | ||
4608 | if (dec_BER_PDU('A0810402810100'O) == myIntegerValue) | |
4609 | ||
4610 | ||
4611 | {setverdict(pass);} else {setverdict(fail);} | |
4612 | ||
4613 | ||
4614 | <RESULT> | |
4615 | ||
4616 | Overall verdict: pass | |
4617 | ||
4618 | <END_TC> | |
4619 | ||
4620 | :exmp. | |
4621 | ||
4622 | .*---------------------------------------------------------------------* | |
4623 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Short form - Short form, DER | |
4624 | .*---------------------------------------------------------------------* | |
4625 | :xmp tab=0. | |
4626 | ||
4627 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Short form - Short form, DER> | |
4628 | ||
4629 | <STATIC:ASN> | |
4630 | ||
4631 | TempA | |
4632 | ||
4633 | DEFINITIONS ::= | |
4634 | BEGIN | |
4635 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
4636 | ||
4637 | myIntegerValue BERPDU ::= 0 | |
4638 | ||
4639 | END | |
4640 | ||
4641 | <STATIC> | |
4642 | ||
4643 | import from TempA all; | |
4644 | ||
4645 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4646 | ||
4647 | ||
4648 | <TTCN_TC:EXEC> | |
4649 | ||
4650 | if (dec_BER_PDU('E103020100'O) == myIntegerValue) | |
4651 | ||
4652 | ||
4653 | {setverdict(pass);} else {setverdict(fail);} | |
4654 | ||
4655 | ||
4656 | <RESULT> | |
4657 | ||
4658 | Overall verdict: pass | |
4659 | ||
4660 | <END_TC> | |
4661 | ||
4662 | :exmp. | |
4663 | ||
4664 | .*---------------------------------------------------------------------* | |
4665 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Short form - long form | |
4666 | .*---------------------------------------------------------------------* | |
4667 | :xmp tab=0. | |
4668 | ||
4669 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Short form - long form> | |
4670 | ||
4671 | <STATIC:ASN> | |
4672 | ||
4673 | TempA | |
4674 | ||
4675 | DEFINITIONS ::= | |
4676 | BEGIN | |
4677 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
4678 | ||
4679 | myIntegerValue BERPDU ::= 0 | |
4680 | ||
4681 | END | |
4682 | ||
4683 | <STATIC> | |
4684 | ||
4685 | import from TempA all; | |
4686 | ||
4687 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4688 | ||
4689 | ||
4690 | <TTCN_TC:EXEC> | |
4691 | ||
4692 | if (dec_BER_PDU('E10402810100'O) == myIntegerValue) | |
4693 | ||
4694 | ||
4695 | {setverdict(pass);} else {setverdict(fail);} | |
4696 | ||
4697 | ||
4698 | <RESULT> | |
4699 | ||
4700 | Overall verdict: pass | |
4701 | ||
4702 | <END_TC> | |
4703 | ||
4704 | :exmp. | |
4705 | ||
4706 | .*---------------------------------------------------------------------* | |
4707 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Long form - short form | |
4708 | .*---------------------------------------------------------------------* | |
4709 | :xmp tab=0. | |
4710 | ||
4711 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Long form - short form> | |
4712 | ||
4713 | <STATIC:ASN> | |
4714 | ||
4715 | TempA | |
4716 | ||
4717 | DEFINITIONS ::= | |
4718 | BEGIN | |
4719 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
4720 | ||
4721 | myIntegerValue BERPDU ::= 0 | |
4722 | ||
4723 | END | |
4724 | ||
4725 | <STATIC> | |
4726 | ||
4727 | import from TempA all; | |
4728 | ||
4729 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4730 | ||
4731 | ||
4732 | <TTCN_TC:EXEC> | |
4733 | ||
4734 | if (dec_BER_PDU('E18103020100'O) == myIntegerValue) | |
4735 | ||
4736 | ||
4737 | {setverdict(pass);} else {setverdict(fail);} | |
4738 | ||
4739 | ||
4740 | <RESULT> | |
4741 | ||
4742 | Overall verdict: pass | |
4743 | ||
4744 | <END_TC> | |
4745 | ||
4746 | :exmp. | |
4747 | ||
4748 | .*---------------------------------------------------------------------* | |
4749 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Long form Long form | |
4750 | .*---------------------------------------------------------------------* | |
4751 | :xmp tab=0. | |
4752 | ||
4753 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0), Long form Long form> | |
4754 | ||
4755 | <STATIC:ASN> | |
4756 | ||
4757 | TempA | |
4758 | ||
4759 | DEFINITIONS ::= | |
4760 | BEGIN | |
4761 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
4762 | ||
4763 | myIntegerValue BERPDU ::= 0 | |
4764 | ||
4765 | END | |
4766 | ||
4767 | <STATIC> | |
4768 | ||
4769 | import from TempA all; | |
4770 | ||
4771 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4772 | ||
4773 | ||
4774 | <TTCN_TC:EXEC> | |
4775 | ||
4776 | if (dec_BER_PDU('E1810402810100'O) == myIntegerValue) | |
4777 | ||
4778 | ||
4779 | {setverdict(pass);} else {setverdict(fail);} | |
4780 | ||
4781 | ||
4782 | <RESULT> | |
4783 | ||
4784 | Overall verdict: pass | |
4785 | ||
4786 | <END_TC> | |
4787 | ||
4788 | :exmp. | |
4789 | ||
4790 | .*---------------------------------------------------------------------* | |
4791 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (0),Indefinite form,CER | |
4792 | .*---------------------------------------------------------------------* | |
4793 | :xmp tab=0. | |
4794 | ||
4795 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (0),Indefinite form,CER> | |
4796 | ||
4797 | <STATIC:ASN> | |
4798 | ||
4799 | TempA | |
4800 | ||
4801 | DEFINITIONS ::= | |
4802 | BEGIN | |
4803 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
4804 | ||
4805 | myIntegerValue BERPDU ::= 0 | |
4806 | ||
4807 | END | |
4808 | ||
4809 | <STATIC> | |
4810 | ||
4811 | import from TempA all; | |
4812 | ||
4813 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4814 | ||
4815 | ||
4816 | <TTCN_TC:EXEC> | |
4817 | ||
4818 | if (dec_BER_PDU('E1800201000000'O) == myIntegerValue) | |
4819 | ||
4820 | ||
4821 | {setverdict(pass);} else {setverdict(fail);} | |
4822 | ||
4823 | ||
4824 | <RESULT> | |
4825 | ||
4826 | Overall verdict: pass | |
4827 | ||
4828 | <END_TC> | |
4829 | ||
4830 | :exmp. | |
4831 | ||
4832 | .*---------------------------------------------------------------------* | |
4833 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Short form - Short form, DER | |
4834 | .*---------------------------------------------------------------------* | |
4835 | :xmp tab=0. | |
4836 | ||
4837 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Short form - Short form, DER> | |
4838 | ||
4839 | <STATIC:ASN> | |
4840 | ||
4841 | TempA | |
4842 | ||
4843 | DEFINITIONS ::= | |
4844 | BEGIN | |
4845 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
4846 | ||
4847 | myIntegerValue BERPDU ::= 0 | |
4848 | ||
4849 | END | |
4850 | ||
4851 | <STATIC> | |
4852 | ||
4853 | import from TempA all; | |
4854 | ||
4855 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4856 | ||
4857 | ||
4858 | <TTCN_TC:EXEC> | |
4859 | ||
4860 | if (dec_BER_PDU('6203020100'O) == myIntegerValue) | |
4861 | ||
4862 | ||
4863 | {setverdict(pass);} else {setverdict(fail);} | |
4864 | ||
4865 | ||
4866 | <RESULT> | |
4867 | ||
4868 | Overall verdict: pass | |
4869 | ||
4870 | <END_TC> | |
4871 | ||
4872 | :exmp. | |
4873 | ||
4874 | .*---------------------------------------------------------------------* | |
4875 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Short form - long form | |
4876 | .*---------------------------------------------------------------------* | |
4877 | :xmp tab=0. | |
4878 | ||
4879 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Short form - long form> | |
4880 | ||
4881 | <STATIC:ASN> | |
4882 | ||
4883 | TempA | |
4884 | ||
4885 | DEFINITIONS ::= | |
4886 | BEGIN | |
4887 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
4888 | ||
4889 | myIntegerValue BERPDU ::= 0 | |
4890 | ||
4891 | END | |
4892 | ||
4893 | <STATIC> | |
4894 | ||
4895 | import from TempA all; | |
4896 | ||
4897 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4898 | ||
4899 | ||
4900 | <TTCN_TC:EXEC> | |
4901 | ||
4902 | if (dec_BER_PDU('620402810100'O) == myIntegerValue) | |
4903 | ||
4904 | ||
4905 | {setverdict(pass);} else {setverdict(fail);} | |
4906 | ||
4907 | ||
4908 | <RESULT> | |
4909 | ||
4910 | Overall verdict: pass | |
4911 | ||
4912 | <END_TC> | |
4913 | ||
4914 | :exmp. | |
4915 | ||
4916 | .*---------------------------------------------------------------------* | |
4917 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Long form - short form | |
4918 | .*---------------------------------------------------------------------* | |
4919 | :xmp tab=0. | |
4920 | ||
4921 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Long form - short form> | |
4922 | ||
4923 | <STATIC:ASN> | |
4924 | ||
4925 | TempA | |
4926 | ||
4927 | DEFINITIONS ::= | |
4928 | BEGIN | |
4929 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
4930 | ||
4931 | myIntegerValue BERPDU ::= 0 | |
4932 | ||
4933 | END | |
4934 | ||
4935 | <STATIC> | |
4936 | ||
4937 | import from TempA all; | |
4938 | ||
4939 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4940 | ||
4941 | ||
4942 | <TTCN_TC:EXEC> | |
4943 | ||
4944 | if (dec_BER_PDU('628103020100'O) == myIntegerValue) | |
4945 | ||
4946 | ||
4947 | {setverdict(pass);} else {setverdict(fail);} | |
4948 | ||
4949 | ||
4950 | <RESULT> | |
4951 | ||
4952 | Overall verdict: pass | |
4953 | ||
4954 | <END_TC> | |
4955 | ||
4956 | :exmp. | |
4957 | ||
4958 | .*---------------------------------------------------------------------* | |
4959 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Long form Long form | |
4960 | .*---------------------------------------------------------------------* | |
4961 | :xmp tab=0. | |
4962 | ||
4963 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0), Long form Long form> | |
4964 | ||
4965 | <STATIC:ASN> | |
4966 | ||
4967 | TempA | |
4968 | ||
4969 | DEFINITIONS ::= | |
4970 | BEGIN | |
4971 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
4972 | ||
4973 | myIntegerValue BERPDU ::= 0 | |
4974 | ||
4975 | END | |
4976 | ||
4977 | <STATIC> | |
4978 | ||
4979 | import from TempA all; | |
4980 | ||
4981 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
4982 | ||
4983 | ||
4984 | <TTCN_TC:EXEC> | |
4985 | ||
4986 | if (dec_BER_PDU('62810402810100'O) == myIntegerValue) | |
4987 | ||
4988 | ||
4989 | {setverdict(pass);} else {setverdict(fail);} | |
4990 | ||
4991 | ||
4992 | <RESULT> | |
4993 | ||
4994 | Overall verdict: pass | |
4995 | ||
4996 | <END_TC> | |
4997 | ||
4998 | :exmp. | |
4999 | ||
5000 | .*---------------------------------------------------------------------* | |
5001 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (0),Indefinite form,CER | |
5002 | .*---------------------------------------------------------------------* | |
5003 | :xmp tab=0. | |
5004 | ||
5005 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (0),Indefinite form,CER> | |
5006 | ||
5007 | <STATIC:ASN> | |
5008 | ||
5009 | TempA | |
5010 | ||
5011 | DEFINITIONS ::= | |
5012 | BEGIN | |
5013 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
5014 | ||
5015 | myIntegerValue BERPDU ::= 0 | |
5016 | ||
5017 | END | |
5018 | ||
5019 | <STATIC> | |
5020 | ||
5021 | import from TempA all; | |
5022 | ||
5023 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5024 | ||
5025 | ||
5026 | <TTCN_TC:EXEC> | |
5027 | ||
5028 | if (dec_BER_PDU('62800201000000'O) == myIntegerValue) | |
5029 | ||
5030 | ||
5031 | {setverdict(pass);} else {setverdict(fail);} | |
5032 | ||
5033 | ||
5034 | <RESULT> | |
5035 | ||
5036 | Overall verdict: pass | |
5037 | ||
5038 | <END_TC> | |
5039 | ||
5040 | :exmp. | |
5041 | ||
5042 | .*---------------------------------------------------------------------* | |
5043 | :h3. DECODING [0] IMPLICIT INTEGER (0),Short form CER,DER | |
5044 | .*---------------------------------------------------------------------* | |
5045 | :xmp tab=0. | |
5046 | ||
5047 | <TC - DECODING [0] IMPLICIT INTEGER (0),Short form CER,DER> | |
5048 | ||
5049 | <STATIC:ASN> | |
5050 | ||
5051 | TempA | |
5052 | ||
5053 | DEFINITIONS ::= | |
5054 | BEGIN | |
5055 | BERPDU ::= [0] IMPLICIT INTEGER | |
5056 | ||
5057 | myIntegerValue BERPDU ::= 0 | |
5058 | ||
5059 | END | |
5060 | ||
5061 | <STATIC> | |
5062 | ||
5063 | import from TempA all; | |
5064 | ||
5065 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5066 | ||
5067 | ||
5068 | <TTCN_TC:EXEC> | |
5069 | ||
5070 | if (dec_BER_PDU('800100'O) == myIntegerValue) | |
5071 | ||
5072 | ||
5073 | {setverdict(pass);} else {setverdict(fail);} | |
5074 | ||
5075 | ||
5076 | <RESULT> | |
5077 | ||
5078 | Overall verdict: pass | |
5079 | ||
5080 | <END_TC> | |
5081 | ||
5082 | :exmp. | |
5083 | ||
5084 | .*---------------------------------------------------------------------* | |
5085 | :h3. DECODING [0] IMPLICIT INTEGER (0),Long form | |
5086 | .*---------------------------------------------------------------------* | |
5087 | :xmp tab=0. | |
5088 | ||
5089 | <TC - DECODING [0] IMPLICIT INTEGER (0),Long form> | |
5090 | ||
5091 | <STATIC:ASN> | |
5092 | ||
5093 | TempA | |
5094 | ||
5095 | DEFINITIONS ::= | |
5096 | BEGIN | |
5097 | BERPDU ::= [0] IMPLICIT INTEGER | |
5098 | ||
5099 | myIntegerValue BERPDU ::= 0 | |
5100 | ||
5101 | END | |
5102 | ||
5103 | <STATIC> | |
5104 | ||
5105 | import from TempA all; | |
5106 | ||
5107 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5108 | ||
5109 | ||
5110 | <TTCN_TC:EXEC> | |
5111 | ||
5112 | if (dec_BER_PDU('80810100'O) == myIntegerValue) | |
5113 | ||
5114 | ||
5115 | {setverdict(pass);} else {setverdict(fail);} | |
5116 | ||
5117 | ||
5118 | <RESULT> | |
5119 | ||
5120 | Overall verdict: pass | |
5121 | ||
5122 | <END_TC> | |
5123 | ||
5124 | :exmp. | |
5125 | ||
5126 | .*---------------------------------------------------------------------* | |
5127 | :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (0),Short form CER,DER | |
5128 | .*---------------------------------------------------------------------* | |
5129 | :xmp tab=0. | |
5130 | ||
5131 | <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (0),Short form CER,DER> | |
5132 | ||
5133 | <STATIC:ASN> | |
5134 | ||
5135 | TempA | |
5136 | ||
5137 | DEFINITIONS ::= | |
5138 | BEGIN | |
5139 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
5140 | ||
5141 | myIntegerValue BERPDU ::= 0 | |
5142 | ||
5143 | END | |
5144 | ||
5145 | <STATIC> | |
5146 | ||
5147 | import from TempA all; | |
5148 | ||
5149 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5150 | ||
5151 | ||
5152 | <TTCN_TC:EXEC> | |
5153 | ||
5154 | if (dec_BER_PDU('C10100'O) == myIntegerValue) | |
5155 | ||
5156 | ||
5157 | {setverdict(pass);} else {setverdict(fail);} | |
5158 | ||
5159 | ||
5160 | <RESULT> | |
5161 | ||
5162 | Overall verdict: pass | |
5163 | ||
5164 | <END_TC> | |
5165 | ||
5166 | :exmp. | |
5167 | ||
5168 | .*---------------------------------------------------------------------* | |
5169 | :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (0),Long form | |
5170 | .*---------------------------------------------------------------------* | |
5171 | :xmp tab=0. | |
5172 | ||
5173 | <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (0),Long form> | |
5174 | ||
5175 | <STATIC:ASN> | |
5176 | ||
5177 | TempA | |
5178 | ||
5179 | DEFINITIONS ::= | |
5180 | BEGIN | |
5181 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
5182 | ||
5183 | myIntegerValue BERPDU ::= 0 | |
5184 | ||
5185 | END | |
5186 | ||
5187 | <STATIC> | |
5188 | ||
5189 | import from TempA all; | |
5190 | ||
5191 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5192 | ||
5193 | ||
5194 | <TTCN_TC:EXEC> | |
5195 | ||
5196 | if (dec_BER_PDU('C1810100'O) == myIntegerValue) | |
5197 | ||
5198 | ||
5199 | {setverdict(pass);} else {setverdict(fail);} | |
5200 | ||
5201 | ||
5202 | <RESULT> | |
5203 | ||
5204 | Overall verdict: pass | |
5205 | ||
5206 | <END_TC> | |
5207 | ||
5208 | :exmp. | |
5209 | ||
5210 | .*---------------------------------------------------------------------* | |
5211 | :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (0),Short form CER,DER | |
5212 | .*---------------------------------------------------------------------* | |
5213 | :xmp tab=0. | |
5214 | ||
5215 | <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (0),Short form CER,DER> | |
5216 | ||
5217 | <STATIC:ASN> | |
5218 | ||
5219 | TempA | |
5220 | ||
5221 | DEFINITIONS ::= | |
5222 | BEGIN | |
5223 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
5224 | ||
5225 | myIntegerValue BERPDU ::= 0 | |
5226 | ||
5227 | END | |
5228 | ||
5229 | <STATIC> | |
5230 | ||
5231 | import from TempA all; | |
5232 | ||
5233 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5234 | ||
5235 | ||
5236 | <TTCN_TC:EXEC> | |
5237 | ||
5238 | if (dec_BER_PDU('420100'O) == myIntegerValue) | |
5239 | ||
5240 | ||
5241 | {setverdict(pass);} else {setverdict(fail);} | |
5242 | ||
5243 | ||
5244 | <RESULT> | |
5245 | ||
5246 | Overall verdict: pass | |
5247 | ||
5248 | <END_TC> | |
5249 | ||
5250 | :exmp. | |
5251 | ||
5252 | .*---------------------------------------------------------------------* | |
5253 | :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (0),Long form | |
5254 | .*---------------------------------------------------------------------* | |
5255 | :xmp tab=0. | |
5256 | ||
5257 | <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (0),Long form> | |
5258 | ||
5259 | <STATIC:ASN> | |
5260 | ||
5261 | TempA | |
5262 | ||
5263 | DEFINITIONS ::= | |
5264 | BEGIN | |
5265 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
5266 | ||
5267 | myIntegerValue BERPDU ::= 0 | |
5268 | ||
5269 | END | |
5270 | ||
5271 | <STATIC> | |
5272 | ||
5273 | import from TempA all; | |
5274 | ||
5275 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5276 | ||
5277 | ||
5278 | <TTCN_TC:EXEC> | |
5279 | ||
5280 | if (dec_BER_PDU('42810100'O) == myIntegerValue) | |
5281 | ||
5282 | ||
5283 | {setverdict(pass);} else {setverdict(fail);} | |
5284 | ||
5285 | ||
5286 | <RESULT> | |
5287 | ||
5288 | Overall verdict: pass | |
5289 | ||
5290 | <END_TC> | |
5291 | ||
5292 | :exmp. | |
5293 | ||
5294 | .*---------------------------------------------------------------------* | |
5295 | :h3. DECODING INTEGER (127), CER+DER | |
5296 | .*---------------------------------------------------------------------* | |
5297 | :xmp tab=0. | |
5298 | ||
5299 | <TC - DECODING INTEGER (127), CER+DER> | |
5300 | ||
5301 | <STATIC:ASN> | |
5302 | ||
5303 | TempA | |
5304 | ||
5305 | DEFINITIONS ::= | |
5306 | BEGIN | |
5307 | BERPDU ::= INTEGER | |
5308 | ||
5309 | myIntegerValue BERPDU ::= 127 | |
5310 | ||
5311 | END | |
5312 | ||
5313 | <STATIC> | |
5314 | ||
5315 | import from TempA all; | |
5316 | ||
5317 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5318 | ||
5319 | ||
5320 | <TTCN_TC:EXEC> | |
5321 | ||
5322 | if (dec_BER_PDU('02017F'O) == myIntegerValue) | |
5323 | ||
5324 | ||
5325 | {setverdict(pass);} else {setverdict(fail);} | |
5326 | ||
5327 | ||
5328 | <RESULT> | |
5329 | ||
5330 | Overall verdict: pass | |
5331 | ||
5332 | <END_TC> | |
5333 | ||
5334 | :exmp. | |
5335 | ||
5336 | .*---------------------------------------------------------------------* | |
5337 | :h3. DECODING INTEGER (127), (LENGTH OF LENGTH = 1) | |
5338 | .*---------------------------------------------------------------------* | |
5339 | :xmp tab=0. | |
5340 | ||
5341 | <TC - DECODING INTEGER (127), (LENGTH OF LENGTH = 1)> | |
5342 | ||
5343 | <STATIC:ASN> | |
5344 | ||
5345 | TempA | |
5346 | ||
5347 | DEFINITIONS ::= | |
5348 | BEGIN | |
5349 | BERPDU ::= INTEGER | |
5350 | ||
5351 | myIntegerValue BERPDU ::= 127 | |
5352 | ||
5353 | END | |
5354 | ||
5355 | <STATIC> | |
5356 | ||
5357 | import from TempA all; | |
5358 | ||
5359 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5360 | ||
5361 | ||
5362 | <TTCN_TC:EXEC> | |
5363 | ||
5364 | if (dec_BER_PDU('0281017F'O) == myIntegerValue) | |
5365 | ||
5366 | ||
5367 | {setverdict(pass);} else {setverdict(fail);} | |
5368 | ||
5369 | ||
5370 | <RESULT> | |
5371 | ||
5372 | Overall verdict: pass | |
5373 | ||
5374 | <END_TC> | |
5375 | ||
5376 | :exmp. | |
5377 | ||
5378 | .*---------------------------------------------------------------------* | |
5379 | :h3. DECODING INTEGER (127), (LENGTH OF LENGTH = 2) | |
5380 | .*---------------------------------------------------------------------* | |
5381 | :xmp tab=0. | |
5382 | ||
5383 | <TC - DECODING INTEGER (127), (LENGTH OF LENGTH = 2)> | |
5384 | ||
5385 | <STATIC:ASN> | |
5386 | ||
5387 | TempA | |
5388 | ||
5389 | DEFINITIONS ::= | |
5390 | BEGIN | |
5391 | BERPDU ::= INTEGER | |
5392 | ||
5393 | myIntegerValue BERPDU ::= 127 | |
5394 | ||
5395 | END | |
5396 | ||
5397 | <STATIC> | |
5398 | ||
5399 | import from TempA all; | |
5400 | ||
5401 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5402 | ||
5403 | ||
5404 | <TTCN_TC:EXEC> | |
5405 | ||
5406 | if (dec_BER_PDU('028200017F'O) == myIntegerValue) | |
5407 | ||
5408 | ||
5409 | {setverdict(pass);} else {setverdict(fail);} | |
5410 | ||
5411 | ||
5412 | <RESULT> | |
5413 | ||
5414 | Overall verdict: pass | |
5415 | ||
5416 | <END_TC> | |
5417 | ||
5418 | :exmp. | |
5419 | ||
5420 | .*---------------------------------------------------------------------* | |
5421 | :h3. DECODING [0] EXPLICIT INTEGER (127), DER | |
5422 | .*---------------------------------------------------------------------* | |
5423 | :xmp tab=0. | |
5424 | ||
5425 | <TC - DECODING [0] EXPLICIT INTEGER (127), DER> | |
5426 | ||
5427 | <STATIC:ASN> | |
5428 | ||
5429 | TempA | |
5430 | ||
5431 | DEFINITIONS ::= | |
5432 | BEGIN | |
5433 | BERPDU ::= [0] EXPLICIT INTEGER | |
5434 | ||
5435 | myIntegerValue BERPDU ::= 127 | |
5436 | ||
5437 | END | |
5438 | ||
5439 | <STATIC> | |
5440 | ||
5441 | import from TempA all; | |
5442 | ||
5443 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5444 | ||
5445 | ||
5446 | <TTCN_TC:EXEC> | |
5447 | ||
5448 | if (dec_BER_PDU('A00302017F'O) == myIntegerValue) | |
5449 | ||
5450 | ||
5451 | {setverdict(pass);} else {setverdict(fail);} | |
5452 | ||
5453 | ||
5454 | <RESULT> | |
5455 | ||
5456 | Overall verdict: pass | |
5457 | ||
5458 | <END_TC> | |
5459 | ||
5460 | :exmp. | |
5461 | ||
5462 | .*---------------------------------------------------------------------* | |
5463 | :h3. DECODING [0] EXPLICIT INTEGER (127), CER | |
5464 | .*---------------------------------------------------------------------* | |
5465 | :xmp tab=0. | |
5466 | ||
5467 | <TC - DECODING [0] EXPLICIT INTEGER (127), CER> | |
5468 | ||
5469 | <STATIC:ASN> | |
5470 | ||
5471 | TempA | |
5472 | ||
5473 | DEFINITIONS ::= | |
5474 | BEGIN | |
5475 | BERPDU ::= [0] EXPLICIT INTEGER | |
5476 | ||
5477 | myIntegerValue BERPDU ::= 127 | |
5478 | ||
5479 | END | |
5480 | ||
5481 | <STATIC> | |
5482 | ||
5483 | import from TempA all; | |
5484 | ||
5485 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5486 | ||
5487 | ||
5488 | <TTCN_TC:EXEC> | |
5489 | ||
5490 | if (dec_BER_PDU('A08002017F0000'O) == myIntegerValue) | |
5491 | ||
5492 | ||
5493 | {setverdict(pass);} else {setverdict(fail);} | |
5494 | ||
5495 | ||
5496 | <RESULT> | |
5497 | ||
5498 | Overall verdict: pass | |
5499 | ||
5500 | <END_TC> | |
5501 | ||
5502 | :exmp. | |
5503 | ||
5504 | .*---------------------------------------------------------------------* | |
5505 | :h3. DECODING [0] EXPLICIT INTEGER (127), Short form - long form | |
5506 | .*---------------------------------------------------------------------* | |
5507 | :xmp tab=0. | |
5508 | ||
5509 | <TC - DECODING [0] EXPLICIT INTEGER (127), Short form - long form> | |
5510 | ||
5511 | <STATIC:ASN> | |
5512 | ||
5513 | TempA | |
5514 | ||
5515 | DEFINITIONS ::= | |
5516 | BEGIN | |
5517 | BERPDU ::= [0] EXPLICIT INTEGER | |
5518 | ||
5519 | myIntegerValue BERPDU ::= 127 | |
5520 | ||
5521 | END | |
5522 | ||
5523 | <STATIC> | |
5524 | ||
5525 | import from TempA all; | |
5526 | ||
5527 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5528 | ||
5529 | ||
5530 | <TTCN_TC:EXEC> | |
5531 | ||
5532 | if (dec_BER_PDU('A00302017F'O) == myIntegerValue) | |
5533 | ||
5534 | ||
5535 | {setverdict(pass);} else {setverdict(fail);} | |
5536 | ||
5537 | ||
5538 | <RESULT> | |
5539 | ||
5540 | Overall verdict: pass | |
5541 | ||
5542 | <END_TC> | |
5543 | ||
5544 | :exmp. | |
5545 | ||
5546 | .*---------------------------------------------------------------------* | |
5547 | :h3. DECODING [0] EXPLICIT INTEGER (127), Long form - short form | |
5548 | .*---------------------------------------------------------------------* | |
5549 | :xmp tab=0. | |
5550 | ||
5551 | <TC - DECODING [0] EXPLICIT INTEGER (127), Long form - short form> | |
5552 | ||
5553 | <STATIC:ASN> | |
5554 | ||
5555 | TempA | |
5556 | ||
5557 | DEFINITIONS ::= | |
5558 | BEGIN | |
5559 | BERPDU ::= [0] EXPLICIT INTEGER | |
5560 | ||
5561 | myIntegerValue BERPDU ::= 127 | |
5562 | ||
5563 | END | |
5564 | ||
5565 | <STATIC> | |
5566 | ||
5567 | import from TempA all; | |
5568 | ||
5569 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5570 | ||
5571 | ||
5572 | <TTCN_TC:EXEC> | |
5573 | ||
5574 | if (dec_BER_PDU('A0810302017F'O) == myIntegerValue) | |
5575 | ||
5576 | ||
5577 | {setverdict(pass);} else {setverdict(fail);} | |
5578 | ||
5579 | ||
5580 | <RESULT> | |
5581 | ||
5582 | Overall verdict: pass | |
5583 | ||
5584 | <END_TC> | |
5585 | ||
5586 | :exmp. | |
5587 | ||
5588 | .*---------------------------------------------------------------------* | |
5589 | :h3. DECODING [0] EXPLICIT INTEGER (127), Long form Long form | |
5590 | .*---------------------------------------------------------------------* | |
5591 | :xmp tab=0. | |
5592 | ||
5593 | <TC - DECODING [0] EXPLICIT INTEGER (127), Long form Long form> | |
5594 | ||
5595 | <STATIC:ASN> | |
5596 | ||
5597 | TempA | |
5598 | ||
5599 | DEFINITIONS ::= | |
5600 | BEGIN | |
5601 | BERPDU ::= [0] EXPLICIT INTEGER | |
5602 | ||
5603 | myIntegerValue BERPDU ::= 127 | |
5604 | ||
5605 | END | |
5606 | ||
5607 | <STATIC> | |
5608 | ||
5609 | import from TempA all; | |
5610 | ||
5611 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5612 | ||
5613 | ||
5614 | <TTCN_TC:EXEC> | |
5615 | ||
5616 | if (dec_BER_PDU('A081040281017F'O) == myIntegerValue) | |
5617 | ||
5618 | ||
5619 | {setverdict(pass);} else {setverdict(fail);} | |
5620 | ||
5621 | ||
5622 | <RESULT> | |
5623 | ||
5624 | Overall verdict: pass | |
5625 | ||
5626 | <END_TC> | |
5627 | ||
5628 | :exmp. | |
5629 | ||
5630 | .*---------------------------------------------------------------------* | |
5631 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Short form - Short form, DER | |
5632 | .*---------------------------------------------------------------------* | |
5633 | :xmp tab=0. | |
5634 | ||
5635 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Short form - Short form, DER> | |
5636 | ||
5637 | <STATIC:ASN> | |
5638 | ||
5639 | TempA | |
5640 | ||
5641 | DEFINITIONS ::= | |
5642 | BEGIN | |
5643 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
5644 | ||
5645 | myIntegerValue BERPDU ::= 127 | |
5646 | ||
5647 | END | |
5648 | ||
5649 | <STATIC> | |
5650 | ||
5651 | import from TempA all; | |
5652 | ||
5653 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5654 | ||
5655 | ||
5656 | <TTCN_TC:EXEC> | |
5657 | ||
5658 | if (dec_BER_PDU('E10302017F'O) == myIntegerValue) | |
5659 | ||
5660 | ||
5661 | {setverdict(pass);} else {setverdict(fail);} | |
5662 | ||
5663 | ||
5664 | <RESULT> | |
5665 | ||
5666 | Overall verdict: pass | |
5667 | ||
5668 | <END_TC> | |
5669 | ||
5670 | :exmp. | |
5671 | ||
5672 | .*---------------------------------------------------------------------* | |
5673 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Short form - long form | |
5674 | .*---------------------------------------------------------------------* | |
5675 | :xmp tab=0. | |
5676 | ||
5677 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Short form - long form> | |
5678 | ||
5679 | <STATIC:ASN> | |
5680 | ||
5681 | TempA | |
5682 | ||
5683 | DEFINITIONS ::= | |
5684 | BEGIN | |
5685 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
5686 | ||
5687 | myIntegerValue BERPDU ::= 127 | |
5688 | ||
5689 | END | |
5690 | ||
5691 | <STATIC> | |
5692 | ||
5693 | import from TempA all; | |
5694 | ||
5695 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5696 | ||
5697 | ||
5698 | <TTCN_TC:EXEC> | |
5699 | ||
5700 | if (dec_BER_PDU('E1040281017F'O) == myIntegerValue) | |
5701 | ||
5702 | ||
5703 | {setverdict(pass);} else {setverdict(fail);} | |
5704 | ||
5705 | ||
5706 | <RESULT> | |
5707 | ||
5708 | Overall verdict: pass | |
5709 | ||
5710 | <END_TC> | |
5711 | ||
5712 | :exmp. | |
5713 | ||
5714 | .*---------------------------------------------------------------------* | |
5715 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Long form - short form | |
5716 | .*---------------------------------------------------------------------* | |
5717 | :xmp tab=0. | |
5718 | ||
5719 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Long form - short form> | |
5720 | ||
5721 | <STATIC:ASN> | |
5722 | ||
5723 | TempA | |
5724 | ||
5725 | DEFINITIONS ::= | |
5726 | BEGIN | |
5727 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
5728 | ||
5729 | myIntegerValue BERPDU ::= 127 | |
5730 | ||
5731 | END | |
5732 | ||
5733 | <STATIC> | |
5734 | ||
5735 | import from TempA all; | |
5736 | ||
5737 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5738 | ||
5739 | ||
5740 | <TTCN_TC:EXEC> | |
5741 | ||
5742 | if (dec_BER_PDU('E1810302017F'O) == myIntegerValue) | |
5743 | ||
5744 | ||
5745 | {setverdict(pass);} else {setverdict(fail);} | |
5746 | ||
5747 | ||
5748 | <RESULT> | |
5749 | ||
5750 | Overall verdict: pass | |
5751 | ||
5752 | <END_TC> | |
5753 | ||
5754 | :exmp. | |
5755 | ||
5756 | .*---------------------------------------------------------------------* | |
5757 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Long form Long form | |
5758 | .*---------------------------------------------------------------------* | |
5759 | :xmp tab=0. | |
5760 | ||
5761 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127), Long form Long form> | |
5762 | ||
5763 | <STATIC:ASN> | |
5764 | ||
5765 | TempA | |
5766 | ||
5767 | DEFINITIONS ::= | |
5768 | BEGIN | |
5769 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
5770 | ||
5771 | myIntegerValue BERPDU ::= 127 | |
5772 | ||
5773 | END | |
5774 | ||
5775 | <STATIC> | |
5776 | ||
5777 | import from TempA all; | |
5778 | ||
5779 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5780 | ||
5781 | ||
5782 | <TTCN_TC:EXEC> | |
5783 | ||
5784 | if (dec_BER_PDU('E181040281017F'O) == myIntegerValue) | |
5785 | ||
5786 | ||
5787 | {setverdict(pass);} else {setverdict(fail);} | |
5788 | ||
5789 | ||
5790 | <RESULT> | |
5791 | ||
5792 | Overall verdict: pass | |
5793 | ||
5794 | <END_TC> | |
5795 | ||
5796 | :exmp. | |
5797 | ||
5798 | .*---------------------------------------------------------------------* | |
5799 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (127),Indefinite form,CER | |
5800 | .*---------------------------------------------------------------------* | |
5801 | :xmp tab=0. | |
5802 | ||
5803 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (127),Indefinite form,CER> | |
5804 | ||
5805 | <STATIC:ASN> | |
5806 | ||
5807 | TempA | |
5808 | ||
5809 | DEFINITIONS ::= | |
5810 | BEGIN | |
5811 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
5812 | ||
5813 | myIntegerValue BERPDU ::= 127 | |
5814 | ||
5815 | END | |
5816 | ||
5817 | <STATIC> | |
5818 | ||
5819 | import from TempA all; | |
5820 | ||
5821 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5822 | ||
5823 | ||
5824 | <TTCN_TC:EXEC> | |
5825 | ||
5826 | if (dec_BER_PDU('E18002017F0000'O) == myIntegerValue) | |
5827 | ||
5828 | ||
5829 | {setverdict(pass);} else {setverdict(fail);} | |
5830 | ||
5831 | ||
5832 | <RESULT> | |
5833 | ||
5834 | Overall verdict: pass | |
5835 | ||
5836 | <END_TC> | |
5837 | ||
5838 | :exmp. | |
5839 | ||
5840 | .*---------------------------------------------------------------------* | |
5841 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Short form - Short form, DER | |
5842 | .*---------------------------------------------------------------------* | |
5843 | :xmp tab=0. | |
5844 | ||
5845 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Short form - Short form, DER> | |
5846 | ||
5847 | <STATIC:ASN> | |
5848 | ||
5849 | TempA | |
5850 | ||
5851 | DEFINITIONS ::= | |
5852 | BEGIN | |
5853 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
5854 | ||
5855 | myIntegerValue BERPDU ::= 127 | |
5856 | ||
5857 | END | |
5858 | ||
5859 | <STATIC> | |
5860 | ||
5861 | import from TempA all; | |
5862 | ||
5863 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5864 | ||
5865 | ||
5866 | <TTCN_TC:EXEC> | |
5867 | ||
5868 | if (dec_BER_PDU('620302017F'O) == myIntegerValue) | |
5869 | ||
5870 | ||
5871 | {setverdict(pass);} else {setverdict(fail);} | |
5872 | ||
5873 | ||
5874 | <RESULT> | |
5875 | ||
5876 | Overall verdict: pass | |
5877 | ||
5878 | <END_TC> | |
5879 | ||
5880 | :exmp. | |
5881 | ||
5882 | .*---------------------------------------------------------------------* | |
5883 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Short form - long form | |
5884 | .*---------------------------------------------------------------------* | |
5885 | :xmp tab=0. | |
5886 | ||
5887 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Short form - long form> | |
5888 | ||
5889 | <STATIC:ASN> | |
5890 | ||
5891 | TempA | |
5892 | ||
5893 | DEFINITIONS ::= | |
5894 | BEGIN | |
5895 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
5896 | ||
5897 | myIntegerValue BERPDU ::= 127 | |
5898 | ||
5899 | END | |
5900 | ||
5901 | <STATIC> | |
5902 | ||
5903 | import from TempA all; | |
5904 | ||
5905 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5906 | ||
5907 | ||
5908 | <TTCN_TC:EXEC> | |
5909 | ||
5910 | if (dec_BER_PDU('62040281017F'O) == myIntegerValue) | |
5911 | ||
5912 | ||
5913 | {setverdict(pass);} else {setverdict(fail);} | |
5914 | ||
5915 | ||
5916 | <RESULT> | |
5917 | ||
5918 | Overall verdict: pass | |
5919 | ||
5920 | <END_TC> | |
5921 | ||
5922 | :exmp. | |
5923 | ||
5924 | .*---------------------------------------------------------------------* | |
5925 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Long form - short form | |
5926 | .*---------------------------------------------------------------------* | |
5927 | :xmp tab=0. | |
5928 | ||
5929 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Long form - short form> | |
5930 | ||
5931 | <STATIC:ASN> | |
5932 | ||
5933 | TempA | |
5934 | ||
5935 | DEFINITIONS ::= | |
5936 | BEGIN | |
5937 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
5938 | ||
5939 | myIntegerValue BERPDU ::= 127 | |
5940 | ||
5941 | END | |
5942 | ||
5943 | <STATIC> | |
5944 | ||
5945 | import from TempA all; | |
5946 | ||
5947 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5948 | ||
5949 | ||
5950 | <TTCN_TC:EXEC> | |
5951 | ||
5952 | if (dec_BER_PDU('62810302017F'O) == myIntegerValue) | |
5953 | ||
5954 | ||
5955 | {setverdict(pass);} else {setverdict(fail);} | |
5956 | ||
5957 | ||
5958 | <RESULT> | |
5959 | ||
5960 | Overall verdict: pass | |
5961 | ||
5962 | <END_TC> | |
5963 | ||
5964 | :exmp. | |
5965 | ||
5966 | .*---------------------------------------------------------------------* | |
5967 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Long form Long form | |
5968 | .*---------------------------------------------------------------------* | |
5969 | :xmp tab=0. | |
5970 | ||
5971 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127), Long form Long form> | |
5972 | ||
5973 | <STATIC:ASN> | |
5974 | ||
5975 | TempA | |
5976 | ||
5977 | DEFINITIONS ::= | |
5978 | BEGIN | |
5979 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
5980 | ||
5981 | myIntegerValue BERPDU ::= 127 | |
5982 | ||
5983 | END | |
5984 | ||
5985 | <STATIC> | |
5986 | ||
5987 | import from TempA all; | |
5988 | ||
5989 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
5990 | ||
5991 | ||
5992 | <TTCN_TC:EXEC> | |
5993 | ||
5994 | if (dec_BER_PDU('6281040281017F'O) == myIntegerValue) | |
5995 | ||
5996 | ||
5997 | {setverdict(pass);} else {setverdict(fail);} | |
5998 | ||
5999 | ||
6000 | <RESULT> | |
6001 | ||
6002 | Overall verdict: pass | |
6003 | ||
6004 | <END_TC> | |
6005 | ||
6006 | :exmp. | |
6007 | ||
6008 | .*---------------------------------------------------------------------* | |
6009 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (127),Indefinite form,CER | |
6010 | .*---------------------------------------------------------------------* | |
6011 | :xmp tab=0. | |
6012 | ||
6013 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (127),Indefinite form,CER> | |
6014 | ||
6015 | <STATIC:ASN> | |
6016 | ||
6017 | TempA | |
6018 | ||
6019 | DEFINITIONS ::= | |
6020 | BEGIN | |
6021 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
6022 | ||
6023 | myIntegerValue BERPDU ::= 127 | |
6024 | ||
6025 | END | |
6026 | ||
6027 | <STATIC> | |
6028 | ||
6029 | import from TempA all; | |
6030 | ||
6031 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6032 | ||
6033 | ||
6034 | <TTCN_TC:EXEC> | |
6035 | ||
6036 | if (dec_BER_PDU('628002017F0000'O) == myIntegerValue) | |
6037 | ||
6038 | ||
6039 | {setverdict(pass);} else {setverdict(fail);} | |
6040 | ||
6041 | ||
6042 | <RESULT> | |
6043 | ||
6044 | Overall verdict: pass | |
6045 | ||
6046 | <END_TC> | |
6047 | ||
6048 | :exmp. | |
6049 | ||
6050 | .*---------------------------------------------------------------------* | |
6051 | :h3. DECODING [0] IMPLICIT INTEGER (127),Short form CER,DER | |
6052 | .*---------------------------------------------------------------------* | |
6053 | :xmp tab=0. | |
6054 | ||
6055 | <TC - DECODING [0] IMPLICIT INTEGER (127),Short form CER,DER> | |
6056 | ||
6057 | <STATIC:ASN> | |
6058 | ||
6059 | TempA | |
6060 | ||
6061 | DEFINITIONS ::= | |
6062 | BEGIN | |
6063 | BERPDU ::= [0] IMPLICIT INTEGER | |
6064 | ||
6065 | myIntegerValue BERPDU ::= 127 | |
6066 | ||
6067 | END | |
6068 | ||
6069 | <STATIC> | |
6070 | ||
6071 | import from TempA all; | |
6072 | ||
6073 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6074 | ||
6075 | ||
6076 | <TTCN_TC:EXEC> | |
6077 | ||
6078 | if (dec_BER_PDU('80017F'O) == myIntegerValue) | |
6079 | ||
6080 | ||
6081 | {setverdict(pass);} else {setverdict(fail);} | |
6082 | ||
6083 | ||
6084 | <RESULT> | |
6085 | ||
6086 | Overall verdict: pass | |
6087 | ||
6088 | <END_TC> | |
6089 | ||
6090 | :exmp. | |
6091 | ||
6092 | .*---------------------------------------------------------------------* | |
6093 | :h3. DECODING [0] IMPLICIT INTEGER (127),Long form | |
6094 | .*---------------------------------------------------------------------* | |
6095 | :xmp tab=0. | |
6096 | ||
6097 | <TC - DECODING [0] IMPLICIT INTEGER (127),Long form> | |
6098 | ||
6099 | <STATIC:ASN> | |
6100 | ||
6101 | TempA | |
6102 | ||
6103 | DEFINITIONS ::= | |
6104 | BEGIN | |
6105 | BERPDU ::= [0] IMPLICIT INTEGER | |
6106 | ||
6107 | myIntegerValue BERPDU ::= 127 | |
6108 | ||
6109 | END | |
6110 | ||
6111 | <STATIC> | |
6112 | ||
6113 | import from TempA all; | |
6114 | ||
6115 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6116 | ||
6117 | ||
6118 | <TTCN_TC:EXEC> | |
6119 | ||
6120 | if (dec_BER_PDU('8081017F'O) == myIntegerValue) | |
6121 | ||
6122 | ||
6123 | {setverdict(pass);} else {setverdict(fail);} | |
6124 | ||
6125 | ||
6126 | <RESULT> | |
6127 | ||
6128 | Overall verdict: pass | |
6129 | ||
6130 | <END_TC> | |
6131 | ||
6132 | :exmp. | |
6133 | ||
6134 | .*---------------------------------------------------------------------* | |
6135 | :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (127),Short form CER,DER | |
6136 | .*---------------------------------------------------------------------* | |
6137 | :xmp tab=0. | |
6138 | ||
6139 | <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (127),Short form CER,DER> | |
6140 | ||
6141 | <STATIC:ASN> | |
6142 | ||
6143 | TempA | |
6144 | ||
6145 | DEFINITIONS ::= | |
6146 | BEGIN | |
6147 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
6148 | ||
6149 | myIntegerValue BERPDU ::= 127 | |
6150 | ||
6151 | END | |
6152 | ||
6153 | <STATIC> | |
6154 | ||
6155 | import from TempA all; | |
6156 | ||
6157 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6158 | ||
6159 | ||
6160 | <TTCN_TC:EXEC> | |
6161 | ||
6162 | if (dec_BER_PDU('C1017F'O) == myIntegerValue) | |
6163 | ||
6164 | ||
6165 | {setverdict(pass);} else {setverdict(fail);} | |
6166 | ||
6167 | ||
6168 | <RESULT> | |
6169 | ||
6170 | Overall verdict: pass | |
6171 | ||
6172 | <END_TC> | |
6173 | ||
6174 | :exmp. | |
6175 | ||
6176 | .*---------------------------------------------------------------------* | |
6177 | :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (127),Long form | |
6178 | .*---------------------------------------------------------------------* | |
6179 | :xmp tab=0. | |
6180 | ||
6181 | <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (127),Long form> | |
6182 | ||
6183 | <STATIC:ASN> | |
6184 | ||
6185 | TempA | |
6186 | ||
6187 | DEFINITIONS ::= | |
6188 | BEGIN | |
6189 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
6190 | ||
6191 | myIntegerValue BERPDU ::= 127 | |
6192 | ||
6193 | END | |
6194 | ||
6195 | <STATIC> | |
6196 | ||
6197 | import from TempA all; | |
6198 | ||
6199 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6200 | ||
6201 | ||
6202 | <TTCN_TC:EXEC> | |
6203 | ||
6204 | if (dec_BER_PDU('C181017F'O) == myIntegerValue) | |
6205 | ||
6206 | ||
6207 | {setverdict(pass);} else {setverdict(fail);} | |
6208 | ||
6209 | ||
6210 | <RESULT> | |
6211 | ||
6212 | Overall verdict: pass | |
6213 | ||
6214 | <END_TC> | |
6215 | ||
6216 | :exmp. | |
6217 | ||
6218 | .*---------------------------------------------------------------------* | |
6219 | :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (127),Short form CER,DER | |
6220 | .*---------------------------------------------------------------------* | |
6221 | :xmp tab=0. | |
6222 | ||
6223 | <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (127),Short form CER,DER> | |
6224 | ||
6225 | <STATIC:ASN> | |
6226 | ||
6227 | TempA | |
6228 | ||
6229 | DEFINITIONS ::= | |
6230 | BEGIN | |
6231 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
6232 | ||
6233 | myIntegerValue BERPDU ::= 127 | |
6234 | ||
6235 | END | |
6236 | ||
6237 | <STATIC> | |
6238 | ||
6239 | import from TempA all; | |
6240 | ||
6241 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6242 | ||
6243 | ||
6244 | <TTCN_TC:EXEC> | |
6245 | ||
6246 | if (dec_BER_PDU('42017F'O) == myIntegerValue) | |
6247 | ||
6248 | ||
6249 | {setverdict(pass);} else {setverdict(fail);} | |
6250 | ||
6251 | ||
6252 | <RESULT> | |
6253 | ||
6254 | Overall verdict: pass | |
6255 | ||
6256 | <END_TC> | |
6257 | ||
6258 | :exmp. | |
6259 | ||
6260 | .*---------------------------------------------------------------------* | |
6261 | :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (127),Long form | |
6262 | .*---------------------------------------------------------------------* | |
6263 | :xmp tab=0. | |
6264 | ||
6265 | <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (127),Long form> | |
6266 | ||
6267 | <STATIC:ASN> | |
6268 | ||
6269 | TempA | |
6270 | ||
6271 | DEFINITIONS ::= | |
6272 | BEGIN | |
6273 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
6274 | ||
6275 | myIntegerValue BERPDU ::= 127 | |
6276 | ||
6277 | END | |
6278 | ||
6279 | <STATIC> | |
6280 | ||
6281 | import from TempA all; | |
6282 | ||
6283 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6284 | ||
6285 | ||
6286 | <TTCN_TC:EXEC> | |
6287 | ||
6288 | if (dec_BER_PDU('4281017F'O) == myIntegerValue) | |
6289 | ||
6290 | ||
6291 | {setverdict(pass);} else {setverdict(fail);} | |
6292 | ||
6293 | ||
6294 | <RESULT> | |
6295 | ||
6296 | Overall verdict: pass | |
6297 | ||
6298 | <END_TC> | |
6299 | ||
6300 | :exmp. | |
6301 | ||
6302 | .*---------------------------------------------------------------------* | |
6303 | :h3. DECODING INTEGER (-128), CER+DER | |
6304 | .*---------------------------------------------------------------------* | |
6305 | :xmp tab=0. | |
6306 | ||
6307 | <TC - DECODING INTEGER (-128), CER+DER> | |
6308 | ||
6309 | <STATIC:ASN> | |
6310 | ||
6311 | TempA | |
6312 | ||
6313 | DEFINITIONS ::= | |
6314 | BEGIN | |
6315 | BERPDU ::= INTEGER | |
6316 | ||
6317 | myIntegerValue BERPDU ::= -128 | |
6318 | ||
6319 | END | |
6320 | ||
6321 | <STATIC> | |
6322 | ||
6323 | import from TempA all; | |
6324 | ||
6325 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6326 | ||
6327 | ||
6328 | <TTCN_TC:EXEC> | |
6329 | ||
6330 | if (dec_BER_PDU('020180'O) == myIntegerValue) | |
6331 | ||
6332 | ||
6333 | {setverdict(pass);} else {setverdict(fail);} | |
6334 | ||
6335 | ||
6336 | <RESULT> | |
6337 | ||
6338 | Overall verdict: pass | |
6339 | ||
6340 | <END_TC> | |
6341 | ||
6342 | :exmp. | |
6343 | ||
6344 | .*---------------------------------------------------------------------* | |
6345 | :h3. DECODING INTEGER (-128), (LENGTH OF LENGTH = 1) | |
6346 | .*---------------------------------------------------------------------* | |
6347 | :xmp tab=0. | |
6348 | ||
6349 | <TC - DECODING INTEGER (-128), (LENGTH OF LENGTH = 1)> | |
6350 | ||
6351 | <STATIC:ASN> | |
6352 | ||
6353 | TempA | |
6354 | ||
6355 | DEFINITIONS ::= | |
6356 | BEGIN | |
6357 | BERPDU ::= INTEGER | |
6358 | ||
6359 | myIntegerValue BERPDU ::= -128 | |
6360 | ||
6361 | END | |
6362 | ||
6363 | <STATIC> | |
6364 | ||
6365 | import from TempA all; | |
6366 | ||
6367 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6368 | ||
6369 | ||
6370 | <TTCN_TC:EXEC> | |
6371 | ||
6372 | if (dec_BER_PDU('02810180'O) == myIntegerValue) | |
6373 | ||
6374 | ||
6375 | {setverdict(pass);} else {setverdict(fail);} | |
6376 | ||
6377 | ||
6378 | <RESULT> | |
6379 | ||
6380 | Overall verdict: pass | |
6381 | ||
6382 | <END_TC> | |
6383 | ||
6384 | :exmp. | |
6385 | ||
6386 | .*---------------------------------------------------------------------* | |
6387 | :h3. DECODING INTEGER (-128), (LENGTH OF LENGTH = 2) | |
6388 | .*---------------------------------------------------------------------* | |
6389 | :xmp tab=0. | |
6390 | ||
6391 | <TC - DECODING INTEGER (-128), (LENGTH OF LENGTH = 2)> | |
6392 | ||
6393 | <STATIC:ASN> | |
6394 | ||
6395 | TempA | |
6396 | ||
6397 | DEFINITIONS ::= | |
6398 | BEGIN | |
6399 | BERPDU ::= INTEGER | |
6400 | ||
6401 | myIntegerValue BERPDU ::= -128 | |
6402 | ||
6403 | END | |
6404 | ||
6405 | <STATIC> | |
6406 | ||
6407 | import from TempA all; | |
6408 | ||
6409 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6410 | ||
6411 | ||
6412 | <TTCN_TC:EXEC> | |
6413 | ||
6414 | if (dec_BER_PDU('0282000180'O) == myIntegerValue) | |
6415 | ||
6416 | ||
6417 | {setverdict(pass);} else {setverdict(fail);} | |
6418 | ||
6419 | ||
6420 | <RESULT> | |
6421 | ||
6422 | Overall verdict: pass | |
6423 | ||
6424 | <END_TC> | |
6425 | ||
6426 | :exmp. | |
6427 | ||
6428 | .*---------------------------------------------------------------------* | |
6429 | :h3. DECODING [0] EXPLICIT INTEGER (-128), DER | |
6430 | .*---------------------------------------------------------------------* | |
6431 | :xmp tab=0. | |
6432 | ||
6433 | <TC - DECODING [0] EXPLICIT INTEGER (-128), DER> | |
6434 | ||
6435 | <STATIC:ASN> | |
6436 | ||
6437 | TempA | |
6438 | ||
6439 | DEFINITIONS ::= | |
6440 | BEGIN | |
6441 | BERPDU ::= [0] EXPLICIT INTEGER | |
6442 | ||
6443 | myIntegerValue BERPDU ::= -128 | |
6444 | ||
6445 | END | |
6446 | ||
6447 | <STATIC> | |
6448 | ||
6449 | import from TempA all; | |
6450 | ||
6451 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6452 | ||
6453 | ||
6454 | <TTCN_TC:EXEC> | |
6455 | ||
6456 | if (dec_BER_PDU('A003020180'O) == myIntegerValue) | |
6457 | ||
6458 | ||
6459 | {setverdict(pass);} else {setverdict(fail);} | |
6460 | ||
6461 | ||
6462 | <RESULT> | |
6463 | ||
6464 | Overall verdict: pass | |
6465 | ||
6466 | <END_TC> | |
6467 | ||
6468 | :exmp. | |
6469 | ||
6470 | .*---------------------------------------------------------------------* | |
6471 | :h3. DECODING [0] EXPLICIT INTEGER (-128), CER | |
6472 | .*---------------------------------------------------------------------* | |
6473 | :xmp tab=0. | |
6474 | ||
6475 | <TC - DECODING [0] EXPLICIT INTEGER (-128), CER> | |
6476 | ||
6477 | <STATIC:ASN> | |
6478 | ||
6479 | TempA | |
6480 | ||
6481 | DEFINITIONS ::= | |
6482 | BEGIN | |
6483 | BERPDU ::= [0] EXPLICIT INTEGER | |
6484 | ||
6485 | myIntegerValue BERPDU ::= -128 | |
6486 | ||
6487 | END | |
6488 | ||
6489 | <STATIC> | |
6490 | ||
6491 | import from TempA all; | |
6492 | ||
6493 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6494 | ||
6495 | ||
6496 | <TTCN_TC:EXEC> | |
6497 | ||
6498 | if (dec_BER_PDU('A0800201800000'O) == myIntegerValue) | |
6499 | ||
6500 | ||
6501 | {setverdict(pass);} else {setverdict(fail);} | |
6502 | ||
6503 | ||
6504 | <RESULT> | |
6505 | ||
6506 | Overall verdict: pass | |
6507 | ||
6508 | <END_TC> | |
6509 | ||
6510 | :exmp. | |
6511 | ||
6512 | .*---------------------------------------------------------------------* | |
6513 | :h3. DECODING [0] EXPLICIT INTEGER (-128), Short form - long form | |
6514 | .*---------------------------------------------------------------------* | |
6515 | :xmp tab=0. | |
6516 | ||
6517 | <TC - DECODING [0] EXPLICIT INTEGER (-128), Short form - long form> | |
6518 | ||
6519 | <STATIC:ASN> | |
6520 | ||
6521 | TempA | |
6522 | ||
6523 | DEFINITIONS ::= | |
6524 | BEGIN | |
6525 | BERPDU ::= [0] EXPLICIT INTEGER | |
6526 | ||
6527 | myIntegerValue BERPDU ::= -128 | |
6528 | ||
6529 | END | |
6530 | ||
6531 | <STATIC> | |
6532 | ||
6533 | import from TempA all; | |
6534 | ||
6535 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6536 | ||
6537 | ||
6538 | <TTCN_TC:EXEC> | |
6539 | ||
6540 | if (dec_BER_PDU('A003020180'O) == myIntegerValue) | |
6541 | ||
6542 | ||
6543 | {setverdict(pass);} else {setverdict(fail);} | |
6544 | ||
6545 | ||
6546 | <RESULT> | |
6547 | ||
6548 | Overall verdict: pass | |
6549 | ||
6550 | <END_TC> | |
6551 | ||
6552 | :exmp. | |
6553 | ||
6554 | .*---------------------------------------------------------------------* | |
6555 | :h3. DECODING [0] EXPLICIT INTEGER (-128), Long form - short form | |
6556 | .*---------------------------------------------------------------------* | |
6557 | :xmp tab=0. | |
6558 | ||
6559 | <TC - DECODING [0] EXPLICIT INTEGER (-128), Long form - short form> | |
6560 | ||
6561 | <STATIC:ASN> | |
6562 | ||
6563 | TempA | |
6564 | ||
6565 | DEFINITIONS ::= | |
6566 | BEGIN | |
6567 | BERPDU ::= [0] EXPLICIT INTEGER | |
6568 | ||
6569 | myIntegerValue BERPDU ::= -128 | |
6570 | ||
6571 | END | |
6572 | ||
6573 | <STATIC> | |
6574 | ||
6575 | import from TempA all; | |
6576 | ||
6577 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6578 | ||
6579 | ||
6580 | <TTCN_TC:EXEC> | |
6581 | ||
6582 | if (dec_BER_PDU('A08103020180'O) == myIntegerValue) | |
6583 | ||
6584 | ||
6585 | {setverdict(pass);} else {setverdict(fail);} | |
6586 | ||
6587 | ||
6588 | <RESULT> | |
6589 | ||
6590 | Overall verdict: pass | |
6591 | ||
6592 | <END_TC> | |
6593 | ||
6594 | :exmp. | |
6595 | ||
6596 | .*---------------------------------------------------------------------* | |
6597 | :h3. DECODING [0] EXPLICIT INTEGER (-128), Long form Long form | |
6598 | .*---------------------------------------------------------------------* | |
6599 | :xmp tab=0. | |
6600 | ||
6601 | <TC - DECODING [0] EXPLICIT INTEGER (-128), Long form Long form> | |
6602 | ||
6603 | <STATIC:ASN> | |
6604 | ||
6605 | TempA | |
6606 | ||
6607 | DEFINITIONS ::= | |
6608 | BEGIN | |
6609 | BERPDU ::= [0] EXPLICIT INTEGER | |
6610 | ||
6611 | myIntegerValue BERPDU ::= -128 | |
6612 | ||
6613 | END | |
6614 | ||
6615 | <STATIC> | |
6616 | ||
6617 | import from TempA all; | |
6618 | ||
6619 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6620 | ||
6621 | ||
6622 | <TTCN_TC:EXEC> | |
6623 | ||
6624 | if (dec_BER_PDU('A0810402810180'O) == myIntegerValue) | |
6625 | ||
6626 | ||
6627 | {setverdict(pass);} else {setverdict(fail);} | |
6628 | ||
6629 | ||
6630 | <RESULT> | |
6631 | ||
6632 | Overall verdict: pass | |
6633 | ||
6634 | <END_TC> | |
6635 | ||
6636 | :exmp. | |
6637 | ||
6638 | .*---------------------------------------------------------------------* | |
6639 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Short form - Short form, DER | |
6640 | .*---------------------------------------------------------------------* | |
6641 | :xmp tab=0. | |
6642 | ||
6643 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Short form - Short form, DER> | |
6644 | ||
6645 | <STATIC:ASN> | |
6646 | ||
6647 | TempA | |
6648 | ||
6649 | DEFINITIONS ::= | |
6650 | BEGIN | |
6651 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
6652 | ||
6653 | myIntegerValue BERPDU ::= -128 | |
6654 | ||
6655 | END | |
6656 | ||
6657 | <STATIC> | |
6658 | ||
6659 | import from TempA all; | |
6660 | ||
6661 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6662 | ||
6663 | ||
6664 | <TTCN_TC:EXEC> | |
6665 | ||
6666 | if (dec_BER_PDU('E103020180'O) == myIntegerValue) | |
6667 | ||
6668 | ||
6669 | {setverdict(pass);} else {setverdict(fail);} | |
6670 | ||
6671 | ||
6672 | <RESULT> | |
6673 | ||
6674 | Overall verdict: pass | |
6675 | ||
6676 | <END_TC> | |
6677 | ||
6678 | :exmp. | |
6679 | ||
6680 | .*---------------------------------------------------------------------* | |
6681 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Short form - long form | |
6682 | .*---------------------------------------------------------------------* | |
6683 | :xmp tab=0. | |
6684 | ||
6685 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Short form - long form> | |
6686 | ||
6687 | <STATIC:ASN> | |
6688 | ||
6689 | TempA | |
6690 | ||
6691 | DEFINITIONS ::= | |
6692 | BEGIN | |
6693 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
6694 | ||
6695 | myIntegerValue BERPDU ::= -128 | |
6696 | ||
6697 | END | |
6698 | ||
6699 | <STATIC> | |
6700 | ||
6701 | import from TempA all; | |
6702 | ||
6703 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6704 | ||
6705 | ||
6706 | <TTCN_TC:EXEC> | |
6707 | ||
6708 | if (dec_BER_PDU('E10402810180'O) == myIntegerValue) | |
6709 | ||
6710 | ||
6711 | {setverdict(pass);} else {setverdict(fail);} | |
6712 | ||
6713 | ||
6714 | <RESULT> | |
6715 | ||
6716 | Overall verdict: pass | |
6717 | ||
6718 | <END_TC> | |
6719 | ||
6720 | :exmp. | |
6721 | ||
6722 | .*---------------------------------------------------------------------* | |
6723 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Long form - short form | |
6724 | .*---------------------------------------------------------------------* | |
6725 | :xmp tab=0. | |
6726 | ||
6727 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Long form - short form> | |
6728 | ||
6729 | <STATIC:ASN> | |
6730 | ||
6731 | TempA | |
6732 | ||
6733 | DEFINITIONS ::= | |
6734 | BEGIN | |
6735 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
6736 | ||
6737 | myIntegerValue BERPDU ::= -128 | |
6738 | ||
6739 | END | |
6740 | ||
6741 | <STATIC> | |
6742 | ||
6743 | import from TempA all; | |
6744 | ||
6745 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6746 | ||
6747 | ||
6748 | <TTCN_TC:EXEC> | |
6749 | ||
6750 | if (dec_BER_PDU('E18103020180'O) == myIntegerValue) | |
6751 | ||
6752 | ||
6753 | {setverdict(pass);} else {setverdict(fail);} | |
6754 | ||
6755 | ||
6756 | <RESULT> | |
6757 | ||
6758 | Overall verdict: pass | |
6759 | ||
6760 | <END_TC> | |
6761 | ||
6762 | :exmp. | |
6763 | ||
6764 | .*---------------------------------------------------------------------* | |
6765 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Long form Long form | |
6766 | .*---------------------------------------------------------------------* | |
6767 | :xmp tab=0. | |
6768 | ||
6769 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128), Long form Long form> | |
6770 | ||
6771 | <STATIC:ASN> | |
6772 | ||
6773 | TempA | |
6774 | ||
6775 | DEFINITIONS ::= | |
6776 | BEGIN | |
6777 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
6778 | ||
6779 | myIntegerValue BERPDU ::= -128 | |
6780 | ||
6781 | END | |
6782 | ||
6783 | <STATIC> | |
6784 | ||
6785 | import from TempA all; | |
6786 | ||
6787 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6788 | ||
6789 | ||
6790 | <TTCN_TC:EXEC> | |
6791 | ||
6792 | if (dec_BER_PDU('E1810402810180'O) == myIntegerValue) | |
6793 | ||
6794 | ||
6795 | {setverdict(pass);} else {setverdict(fail);} | |
6796 | ||
6797 | ||
6798 | <RESULT> | |
6799 | ||
6800 | Overall verdict: pass | |
6801 | ||
6802 | <END_TC> | |
6803 | ||
6804 | :exmp. | |
6805 | ||
6806 | .*---------------------------------------------------------------------* | |
6807 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-128),Indefinite form,CER | |
6808 | .*---------------------------------------------------------------------* | |
6809 | :xmp tab=0. | |
6810 | ||
6811 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-128),Indefinite form,CER> | |
6812 | ||
6813 | <STATIC:ASN> | |
6814 | ||
6815 | TempA | |
6816 | ||
6817 | DEFINITIONS ::= | |
6818 | BEGIN | |
6819 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
6820 | ||
6821 | myIntegerValue BERPDU ::= -128 | |
6822 | ||
6823 | END | |
6824 | ||
6825 | <STATIC> | |
6826 | ||
6827 | import from TempA all; | |
6828 | ||
6829 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6830 | ||
6831 | ||
6832 | <TTCN_TC:EXEC> | |
6833 | ||
6834 | if (dec_BER_PDU('E1800201800000'O) == myIntegerValue) | |
6835 | ||
6836 | ||
6837 | {setverdict(pass);} else {setverdict(fail);} | |
6838 | ||
6839 | ||
6840 | <RESULT> | |
6841 | ||
6842 | Overall verdict: pass | |
6843 | ||
6844 | <END_TC> | |
6845 | ||
6846 | :exmp. | |
6847 | ||
6848 | .*---------------------------------------------------------------------* | |
6849 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Short form - Short form, DER | |
6850 | .*---------------------------------------------------------------------* | |
6851 | :xmp tab=0. | |
6852 | ||
6853 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Short form - Short form, DER> | |
6854 | ||
6855 | <STATIC:ASN> | |
6856 | ||
6857 | TempA | |
6858 | ||
6859 | DEFINITIONS ::= | |
6860 | BEGIN | |
6861 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
6862 | ||
6863 | myIntegerValue BERPDU ::= -128 | |
6864 | ||
6865 | END | |
6866 | ||
6867 | <STATIC> | |
6868 | ||
6869 | import from TempA all; | |
6870 | ||
6871 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6872 | ||
6873 | ||
6874 | <TTCN_TC:EXEC> | |
6875 | ||
6876 | if (dec_BER_PDU('6203020180'O) == myIntegerValue) | |
6877 | ||
6878 | ||
6879 | {setverdict(pass);} else {setverdict(fail);} | |
6880 | ||
6881 | ||
6882 | <RESULT> | |
6883 | ||
6884 | Overall verdict: pass | |
6885 | ||
6886 | <END_TC> | |
6887 | ||
6888 | :exmp. | |
6889 | ||
6890 | .*---------------------------------------------------------------------* | |
6891 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Short form - long form | |
6892 | .*---------------------------------------------------------------------* | |
6893 | :xmp tab=0. | |
6894 | ||
6895 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Short form - long form> | |
6896 | ||
6897 | <STATIC:ASN> | |
6898 | ||
6899 | TempA | |
6900 | ||
6901 | DEFINITIONS ::= | |
6902 | BEGIN | |
6903 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
6904 | ||
6905 | myIntegerValue BERPDU ::= -128 | |
6906 | ||
6907 | END | |
6908 | ||
6909 | <STATIC> | |
6910 | ||
6911 | import from TempA all; | |
6912 | ||
6913 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6914 | ||
6915 | ||
6916 | <TTCN_TC:EXEC> | |
6917 | ||
6918 | if (dec_BER_PDU('620402810180'O) == myIntegerValue) | |
6919 | ||
6920 | ||
6921 | {setverdict(pass);} else {setverdict(fail);} | |
6922 | ||
6923 | ||
6924 | <RESULT> | |
6925 | ||
6926 | Overall verdict: pass | |
6927 | ||
6928 | <END_TC> | |
6929 | ||
6930 | :exmp. | |
6931 | ||
6932 | .*---------------------------------------------------------------------* | |
6933 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Long form - short form | |
6934 | .*---------------------------------------------------------------------* | |
6935 | :xmp tab=0. | |
6936 | ||
6937 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Long form - short form> | |
6938 | ||
6939 | <STATIC:ASN> | |
6940 | ||
6941 | TempA | |
6942 | ||
6943 | DEFINITIONS ::= | |
6944 | BEGIN | |
6945 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
6946 | ||
6947 | myIntegerValue BERPDU ::= -128 | |
6948 | ||
6949 | END | |
6950 | ||
6951 | <STATIC> | |
6952 | ||
6953 | import from TempA all; | |
6954 | ||
6955 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6956 | ||
6957 | ||
6958 | <TTCN_TC:EXEC> | |
6959 | ||
6960 | if (dec_BER_PDU('628103020180'O) == myIntegerValue) | |
6961 | ||
6962 | ||
6963 | {setverdict(pass);} else {setverdict(fail);} | |
6964 | ||
6965 | ||
6966 | <RESULT> | |
6967 | ||
6968 | Overall verdict: pass | |
6969 | ||
6970 | <END_TC> | |
6971 | ||
6972 | :exmp. | |
6973 | ||
6974 | .*---------------------------------------------------------------------* | |
6975 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Long form Long form | |
6976 | .*---------------------------------------------------------------------* | |
6977 | :xmp tab=0. | |
6978 | ||
6979 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128), Long form Long form> | |
6980 | ||
6981 | <STATIC:ASN> | |
6982 | ||
6983 | TempA | |
6984 | ||
6985 | DEFINITIONS ::= | |
6986 | BEGIN | |
6987 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
6988 | ||
6989 | myIntegerValue BERPDU ::= -128 | |
6990 | ||
6991 | END | |
6992 | ||
6993 | <STATIC> | |
6994 | ||
6995 | import from TempA all; | |
6996 | ||
6997 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
6998 | ||
6999 | ||
7000 | <TTCN_TC:EXEC> | |
7001 | ||
7002 | if (dec_BER_PDU('62810402810180'O) == myIntegerValue) | |
7003 | ||
7004 | ||
7005 | {setverdict(pass);} else {setverdict(fail);} | |
7006 | ||
7007 | ||
7008 | <RESULT> | |
7009 | ||
7010 | Overall verdict: pass | |
7011 | ||
7012 | <END_TC> | |
7013 | ||
7014 | :exmp. | |
7015 | ||
7016 | .*---------------------------------------------------------------------* | |
7017 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-128),Indefinite form,CER | |
7018 | .*---------------------------------------------------------------------* | |
7019 | :xmp tab=0. | |
7020 | ||
7021 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-128),Indefinite form,CER> | |
7022 | ||
7023 | <STATIC:ASN> | |
7024 | ||
7025 | TempA | |
7026 | ||
7027 | DEFINITIONS ::= | |
7028 | BEGIN | |
7029 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
7030 | ||
7031 | myIntegerValue BERPDU ::= -128 | |
7032 | ||
7033 | END | |
7034 | ||
7035 | <STATIC> | |
7036 | ||
7037 | import from TempA all; | |
7038 | ||
7039 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7040 | ||
7041 | ||
7042 | <TTCN_TC:EXEC> | |
7043 | ||
7044 | if (dec_BER_PDU('62800201800000'O) == myIntegerValue) | |
7045 | ||
7046 | ||
7047 | {setverdict(pass);} else {setverdict(fail);} | |
7048 | ||
7049 | ||
7050 | <RESULT> | |
7051 | ||
7052 | Overall verdict: pass | |
7053 | ||
7054 | <END_TC> | |
7055 | ||
7056 | :exmp. | |
7057 | ||
7058 | .*---------------------------------------------------------------------* | |
7059 | :h3. DECODING [0] IMPLICIT INTEGER (-128),Short form CER,DER | |
7060 | .*---------------------------------------------------------------------* | |
7061 | :xmp tab=0. | |
7062 | ||
7063 | <TC - DECODING [0] IMPLICIT INTEGER (-128),Short form CER,DER> | |
7064 | ||
7065 | <STATIC:ASN> | |
7066 | ||
7067 | TempA | |
7068 | ||
7069 | DEFINITIONS ::= | |
7070 | BEGIN | |
7071 | BERPDU ::= [0] IMPLICIT INTEGER | |
7072 | ||
7073 | myIntegerValue BERPDU ::= -128 | |
7074 | ||
7075 | END | |
7076 | ||
7077 | <STATIC> | |
7078 | ||
7079 | import from TempA all; | |
7080 | ||
7081 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7082 | ||
7083 | ||
7084 | <TTCN_TC:EXEC> | |
7085 | ||
7086 | if (dec_BER_PDU('800180'O) == myIntegerValue) | |
7087 | ||
7088 | ||
7089 | {setverdict(pass);} else {setverdict(fail);} | |
7090 | ||
7091 | ||
7092 | <RESULT> | |
7093 | ||
7094 | Overall verdict: pass | |
7095 | ||
7096 | <END_TC> | |
7097 | ||
7098 | :exmp. | |
7099 | ||
7100 | .*---------------------------------------------------------------------* | |
7101 | :h3. DECODING [0] IMPLICIT INTEGER (-128),Long form | |
7102 | .*---------------------------------------------------------------------* | |
7103 | :xmp tab=0. | |
7104 | ||
7105 | <TC - DECODING [0] IMPLICIT INTEGER (-128),Long form> | |
7106 | ||
7107 | <STATIC:ASN> | |
7108 | ||
7109 | TempA | |
7110 | ||
7111 | DEFINITIONS ::= | |
7112 | BEGIN | |
7113 | BERPDU ::= [0] IMPLICIT INTEGER | |
7114 | ||
7115 | myIntegerValue BERPDU ::= -128 | |
7116 | ||
7117 | END | |
7118 | ||
7119 | <STATIC> | |
7120 | ||
7121 | import from TempA all; | |
7122 | ||
7123 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7124 | ||
7125 | ||
7126 | <TTCN_TC:EXEC> | |
7127 | ||
7128 | if (dec_BER_PDU('80810180'O) == myIntegerValue) | |
7129 | ||
7130 | ||
7131 | {setverdict(pass);} else {setverdict(fail);} | |
7132 | ||
7133 | ||
7134 | <RESULT> | |
7135 | ||
7136 | Overall verdict: pass | |
7137 | ||
7138 | <END_TC> | |
7139 | ||
7140 | :exmp. | |
7141 | ||
7142 | .*---------------------------------------------------------------------* | |
7143 | :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-128),Short form CER,DER | |
7144 | .*---------------------------------------------------------------------* | |
7145 | :xmp tab=0. | |
7146 | ||
7147 | <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-128),Short form CER,DER> | |
7148 | ||
7149 | <STATIC:ASN> | |
7150 | ||
7151 | TempA | |
7152 | ||
7153 | DEFINITIONS ::= | |
7154 | BEGIN | |
7155 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
7156 | ||
7157 | myIntegerValue BERPDU ::= -128 | |
7158 | ||
7159 | END | |
7160 | ||
7161 | <STATIC> | |
7162 | ||
7163 | import from TempA all; | |
7164 | ||
7165 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7166 | ||
7167 | ||
7168 | <TTCN_TC:EXEC> | |
7169 | ||
7170 | if (dec_BER_PDU('C10180'O) == myIntegerValue) | |
7171 | ||
7172 | ||
7173 | {setverdict(pass);} else {setverdict(fail);} | |
7174 | ||
7175 | ||
7176 | <RESULT> | |
7177 | ||
7178 | Overall verdict: pass | |
7179 | ||
7180 | <END_TC> | |
7181 | ||
7182 | :exmp. | |
7183 | ||
7184 | .*---------------------------------------------------------------------* | |
7185 | :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-128),Long form | |
7186 | .*---------------------------------------------------------------------* | |
7187 | :xmp tab=0. | |
7188 | ||
7189 | <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-128),Long form> | |
7190 | ||
7191 | <STATIC:ASN> | |
7192 | ||
7193 | TempA | |
7194 | ||
7195 | DEFINITIONS ::= | |
7196 | BEGIN | |
7197 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
7198 | ||
7199 | myIntegerValue BERPDU ::= -128 | |
7200 | ||
7201 | END | |
7202 | ||
7203 | <STATIC> | |
7204 | ||
7205 | import from TempA all; | |
7206 | ||
7207 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7208 | ||
7209 | ||
7210 | <TTCN_TC:EXEC> | |
7211 | ||
7212 | if (dec_BER_PDU('C1810180'O) == myIntegerValue) | |
7213 | ||
7214 | ||
7215 | {setverdict(pass);} else {setverdict(fail);} | |
7216 | ||
7217 | ||
7218 | <RESULT> | |
7219 | ||
7220 | Overall verdict: pass | |
7221 | ||
7222 | <END_TC> | |
7223 | ||
7224 | :exmp. | |
7225 | ||
7226 | .*---------------------------------------------------------------------* | |
7227 | :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-128),Short form CER,DER | |
7228 | .*---------------------------------------------------------------------* | |
7229 | :xmp tab=0. | |
7230 | ||
7231 | <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-128),Short form CER,DER> | |
7232 | ||
7233 | <STATIC:ASN> | |
7234 | ||
7235 | TempA | |
7236 | ||
7237 | DEFINITIONS ::= | |
7238 | BEGIN | |
7239 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
7240 | ||
7241 | myIntegerValue BERPDU ::= -128 | |
7242 | ||
7243 | END | |
7244 | ||
7245 | <STATIC> | |
7246 | ||
7247 | import from TempA all; | |
7248 | ||
7249 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7250 | ||
7251 | ||
7252 | <TTCN_TC:EXEC> | |
7253 | ||
7254 | if (dec_BER_PDU('420180'O) == myIntegerValue) | |
7255 | ||
7256 | ||
7257 | {setverdict(pass);} else {setverdict(fail);} | |
7258 | ||
7259 | ||
7260 | <RESULT> | |
7261 | ||
7262 | Overall verdict: pass | |
7263 | ||
7264 | <END_TC> | |
7265 | ||
7266 | :exmp. | |
7267 | ||
7268 | .*---------------------------------------------------------------------* | |
7269 | :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-128),Long form | |
7270 | .*---------------------------------------------------------------------* | |
7271 | :xmp tab=0. | |
7272 | ||
7273 | <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-128),Long form> | |
7274 | ||
7275 | <STATIC:ASN> | |
7276 | ||
7277 | TempA | |
7278 | ||
7279 | DEFINITIONS ::= | |
7280 | BEGIN | |
7281 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
7282 | ||
7283 | myIntegerValue BERPDU ::= -128 | |
7284 | ||
7285 | END | |
7286 | ||
7287 | <STATIC> | |
7288 | ||
7289 | import from TempA all; | |
7290 | ||
7291 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7292 | ||
7293 | ||
7294 | <TTCN_TC:EXEC> | |
7295 | ||
7296 | if (dec_BER_PDU('42810180'O) == myIntegerValue) | |
7297 | ||
7298 | ||
7299 | {setverdict(pass);} else {setverdict(fail);} | |
7300 | ||
7301 | ||
7302 | <RESULT> | |
7303 | ||
7304 | Overall verdict: pass | |
7305 | ||
7306 | <END_TC> | |
7307 | ||
7308 | :exmp. | |
7309 | ||
7310 | .*---------------------------------------------------------------------* | |
7311 | :h3. DECODING INTEGER (-5), CER+DER | |
7312 | .*---------------------------------------------------------------------* | |
7313 | :xmp tab=0. | |
7314 | ||
7315 | <TC - DECODING INTEGER (-5), CER+DER> | |
7316 | ||
7317 | <STATIC:ASN> | |
7318 | ||
7319 | TempA | |
7320 | ||
7321 | DEFINITIONS ::= | |
7322 | BEGIN | |
7323 | BERPDU ::= INTEGER | |
7324 | ||
7325 | myIntegerValue BERPDU ::= -5 | |
7326 | ||
7327 | END | |
7328 | ||
7329 | <STATIC> | |
7330 | ||
7331 | import from TempA all; | |
7332 | ||
7333 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7334 | ||
7335 | ||
7336 | <TTCN_TC:EXEC> | |
7337 | ||
7338 | if (dec_BER_PDU('0201FB'O) == myIntegerValue) | |
7339 | ||
7340 | ||
7341 | {setverdict(pass);} else {setverdict(fail);} | |
7342 | ||
7343 | ||
7344 | <RESULT> | |
7345 | ||
7346 | Overall verdict: pass | |
7347 | ||
7348 | <END_TC> | |
7349 | ||
7350 | :exmp. | |
7351 | ||
7352 | .*---------------------------------------------------------------------* | |
7353 | :h3. DECODING INTEGER (-5), (LENGTH OF LENGTH = 1) | |
7354 | .*---------------------------------------------------------------------* | |
7355 | :xmp tab=0. | |
7356 | ||
7357 | <TC - DECODING INTEGER (-5), (LENGTH OF LENGTH = 1)> | |
7358 | ||
7359 | <STATIC:ASN> | |
7360 | ||
7361 | TempA | |
7362 | ||
7363 | DEFINITIONS ::= | |
7364 | BEGIN | |
7365 | BERPDU ::= INTEGER | |
7366 | ||
7367 | myIntegerValue BERPDU ::= -5 | |
7368 | ||
7369 | END | |
7370 | ||
7371 | <STATIC> | |
7372 | ||
7373 | import from TempA all; | |
7374 | ||
7375 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7376 | ||
7377 | ||
7378 | <TTCN_TC:EXEC> | |
7379 | ||
7380 | if (dec_BER_PDU('028101FB'O) == myIntegerValue) | |
7381 | ||
7382 | ||
7383 | {setverdict(pass);} else {setverdict(fail);} | |
7384 | ||
7385 | ||
7386 | <RESULT> | |
7387 | ||
7388 | Overall verdict: pass | |
7389 | ||
7390 | <END_TC> | |
7391 | ||
7392 | :exmp. | |
7393 | ||
7394 | .*---------------------------------------------------------------------* | |
7395 | :h3. DECODING INTEGER (-5), (LENGTH OF LENGTH = 2) | |
7396 | .*---------------------------------------------------------------------* | |
7397 | :xmp tab=0. | |
7398 | ||
7399 | <TC - DECODING INTEGER (-5), (LENGTH OF LENGTH = 2)> | |
7400 | ||
7401 | <STATIC:ASN> | |
7402 | ||
7403 | TempA | |
7404 | ||
7405 | DEFINITIONS ::= | |
7406 | BEGIN | |
7407 | BERPDU ::= INTEGER | |
7408 | ||
7409 | myIntegerValue BERPDU ::= -5 | |
7410 | ||
7411 | END | |
7412 | ||
7413 | <STATIC> | |
7414 | ||
7415 | import from TempA all; | |
7416 | ||
7417 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7418 | ||
7419 | ||
7420 | <TTCN_TC:EXEC> | |
7421 | ||
7422 | if (dec_BER_PDU('02820001FB'O) == myIntegerValue) | |
7423 | ||
7424 | ||
7425 | {setverdict(pass);} else {setverdict(fail);} | |
7426 | ||
7427 | ||
7428 | <RESULT> | |
7429 | ||
7430 | Overall verdict: pass | |
7431 | ||
7432 | <END_TC> | |
7433 | ||
7434 | :exmp. | |
7435 | ||
7436 | .*---------------------------------------------------------------------* | |
7437 | :h3. DECODING [0] EXPLICIT INTEGER (-5), DER | |
7438 | .*---------------------------------------------------------------------* | |
7439 | :xmp tab=0. | |
7440 | ||
7441 | <TC - DECODING [0] EXPLICIT INTEGER (-5), DER> | |
7442 | ||
7443 | <STATIC:ASN> | |
7444 | ||
7445 | TempA | |
7446 | ||
7447 | DEFINITIONS ::= | |
7448 | BEGIN | |
7449 | BERPDU ::= [0] EXPLICIT INTEGER | |
7450 | ||
7451 | myIntegerValue BERPDU ::= -5 | |
7452 | ||
7453 | END | |
7454 | ||
7455 | <STATIC> | |
7456 | ||
7457 | import from TempA all; | |
7458 | ||
7459 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7460 | ||
7461 | ||
7462 | <TTCN_TC:EXEC> | |
7463 | ||
7464 | if (dec_BER_PDU('A0030201FB'O) == myIntegerValue) | |
7465 | ||
7466 | ||
7467 | {setverdict(pass);} else {setverdict(fail);} | |
7468 | ||
7469 | ||
7470 | <RESULT> | |
7471 | ||
7472 | Overall verdict: pass | |
7473 | ||
7474 | <END_TC> | |
7475 | ||
7476 | :exmp. | |
7477 | ||
7478 | .*---------------------------------------------------------------------* | |
7479 | :h3. DECODING [0] EXPLICIT INTEGER (-5), CER | |
7480 | .*---------------------------------------------------------------------* | |
7481 | :xmp tab=0. | |
7482 | ||
7483 | <TC - DECODING [0] EXPLICIT INTEGER (-5), CER> | |
7484 | ||
7485 | <STATIC:ASN> | |
7486 | ||
7487 | TempA | |
7488 | ||
7489 | DEFINITIONS ::= | |
7490 | BEGIN | |
7491 | BERPDU ::= [0] EXPLICIT INTEGER | |
7492 | ||
7493 | myIntegerValue BERPDU ::= -5 | |
7494 | ||
7495 | END | |
7496 | ||
7497 | <STATIC> | |
7498 | ||
7499 | import from TempA all; | |
7500 | ||
7501 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7502 | ||
7503 | ||
7504 | <TTCN_TC:EXEC> | |
7505 | ||
7506 | if (dec_BER_PDU('A0800201FB0000'O) == myIntegerValue) | |
7507 | ||
7508 | ||
7509 | {setverdict(pass);} else {setverdict(fail);} | |
7510 | ||
7511 | ||
7512 | <RESULT> | |
7513 | ||
7514 | Overall verdict: pass | |
7515 | ||
7516 | <END_TC> | |
7517 | ||
7518 | :exmp. | |
7519 | ||
7520 | .*---------------------------------------------------------------------* | |
7521 | :h3. DECODING [0] EXPLICIT INTEGER (-5), Short form - long form | |
7522 | .*---------------------------------------------------------------------* | |
7523 | :xmp tab=0. | |
7524 | ||
7525 | <TC - DECODING [0] EXPLICIT INTEGER (-5), Short form - long form> | |
7526 | ||
7527 | <STATIC:ASN> | |
7528 | ||
7529 | TempA | |
7530 | ||
7531 | DEFINITIONS ::= | |
7532 | BEGIN | |
7533 | BERPDU ::= [0] EXPLICIT INTEGER | |
7534 | ||
7535 | myIntegerValue BERPDU ::= -5 | |
7536 | ||
7537 | END | |
7538 | ||
7539 | <STATIC> | |
7540 | ||
7541 | import from TempA all; | |
7542 | ||
7543 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7544 | ||
7545 | ||
7546 | <TTCN_TC:EXEC> | |
7547 | ||
7548 | if (dec_BER_PDU('A0030201FB'O) == myIntegerValue) | |
7549 | ||
7550 | ||
7551 | {setverdict(pass);} else {setverdict(fail);} | |
7552 | ||
7553 | ||
7554 | <RESULT> | |
7555 | ||
7556 | Overall verdict: pass | |
7557 | ||
7558 | <END_TC> | |
7559 | ||
7560 | :exmp. | |
7561 | ||
7562 | .*---------------------------------------------------------------------* | |
7563 | :h3. DECODING [0] EXPLICIT INTEGER (-5), Long form - short form | |
7564 | .*---------------------------------------------------------------------* | |
7565 | :xmp tab=0. | |
7566 | ||
7567 | <TC - DECODING [0] EXPLICIT INTEGER (-5), Long form - short form> | |
7568 | ||
7569 | <STATIC:ASN> | |
7570 | ||
7571 | TempA | |
7572 | ||
7573 | DEFINITIONS ::= | |
7574 | BEGIN | |
7575 | BERPDU ::= [0] EXPLICIT INTEGER | |
7576 | ||
7577 | myIntegerValue BERPDU ::= -5 | |
7578 | ||
7579 | END | |
7580 | ||
7581 | <STATIC> | |
7582 | ||
7583 | import from TempA all; | |
7584 | ||
7585 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7586 | ||
7587 | ||
7588 | <TTCN_TC:EXEC> | |
7589 | ||
7590 | if (dec_BER_PDU('A081030201FB'O) == myIntegerValue) | |
7591 | ||
7592 | ||
7593 | {setverdict(pass);} else {setverdict(fail);} | |
7594 | ||
7595 | ||
7596 | <RESULT> | |
7597 | ||
7598 | Overall verdict: pass | |
7599 | ||
7600 | <END_TC> | |
7601 | ||
7602 | :exmp. | |
7603 | ||
7604 | .*---------------------------------------------------------------------* | |
7605 | :h3. DECODING [0] EXPLICIT INTEGER (-5), Long form Long form | |
7606 | .*---------------------------------------------------------------------* | |
7607 | :xmp tab=0. | |
7608 | ||
7609 | <TC - DECODING [0] EXPLICIT INTEGER (-5), Long form Long form> | |
7610 | ||
7611 | <STATIC:ASN> | |
7612 | ||
7613 | TempA | |
7614 | ||
7615 | DEFINITIONS ::= | |
7616 | BEGIN | |
7617 | BERPDU ::= [0] EXPLICIT INTEGER | |
7618 | ||
7619 | myIntegerValue BERPDU ::= -5 | |
7620 | ||
7621 | END | |
7622 | ||
7623 | <STATIC> | |
7624 | ||
7625 | import from TempA all; | |
7626 | ||
7627 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7628 | ||
7629 | ||
7630 | <TTCN_TC:EXEC> | |
7631 | ||
7632 | if (dec_BER_PDU('A08104028101FB'O) == myIntegerValue) | |
7633 | ||
7634 | ||
7635 | {setverdict(pass);} else {setverdict(fail);} | |
7636 | ||
7637 | ||
7638 | <RESULT> | |
7639 | ||
7640 | Overall verdict: pass | |
7641 | ||
7642 | <END_TC> | |
7643 | ||
7644 | :exmp. | |
7645 | ||
7646 | .*---------------------------------------------------------------------* | |
7647 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Short form - Short form, DER | |
7648 | .*---------------------------------------------------------------------* | |
7649 | :xmp tab=0. | |
7650 | ||
7651 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Short form - Short form, DER> | |
7652 | ||
7653 | <STATIC:ASN> | |
7654 | ||
7655 | TempA | |
7656 | ||
7657 | DEFINITIONS ::= | |
7658 | BEGIN | |
7659 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
7660 | ||
7661 | myIntegerValue BERPDU ::= -5 | |
7662 | ||
7663 | END | |
7664 | ||
7665 | <STATIC> | |
7666 | ||
7667 | import from TempA all; | |
7668 | ||
7669 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7670 | ||
7671 | ||
7672 | <TTCN_TC:EXEC> | |
7673 | ||
7674 | if (dec_BER_PDU('E1030201FB'O) == myIntegerValue) | |
7675 | ||
7676 | ||
7677 | {setverdict(pass);} else {setverdict(fail);} | |
7678 | ||
7679 | ||
7680 | <RESULT> | |
7681 | ||
7682 | Overall verdict: pass | |
7683 | ||
7684 | <END_TC> | |
7685 | ||
7686 | :exmp. | |
7687 | ||
7688 | .*---------------------------------------------------------------------* | |
7689 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Short form - long form | |
7690 | .*---------------------------------------------------------------------* | |
7691 | :xmp tab=0. | |
7692 | ||
7693 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Short form - long form> | |
7694 | ||
7695 | <STATIC:ASN> | |
7696 | ||
7697 | TempA | |
7698 | ||
7699 | DEFINITIONS ::= | |
7700 | BEGIN | |
7701 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
7702 | ||
7703 | myIntegerValue BERPDU ::= -5 | |
7704 | ||
7705 | END | |
7706 | ||
7707 | <STATIC> | |
7708 | ||
7709 | import from TempA all; | |
7710 | ||
7711 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7712 | ||
7713 | ||
7714 | <TTCN_TC:EXEC> | |
7715 | ||
7716 | if (dec_BER_PDU('E104028101FB'O) == myIntegerValue) | |
7717 | ||
7718 | ||
7719 | {setverdict(pass);} else {setverdict(fail);} | |
7720 | ||
7721 | ||
7722 | <RESULT> | |
7723 | ||
7724 | Overall verdict: pass | |
7725 | ||
7726 | <END_TC> | |
7727 | ||
7728 | :exmp. | |
7729 | ||
7730 | .*---------------------------------------------------------------------* | |
7731 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Long form - short form | |
7732 | .*---------------------------------------------------------------------* | |
7733 | :xmp tab=0. | |
7734 | ||
7735 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Long form - short form> | |
7736 | ||
7737 | <STATIC:ASN> | |
7738 | ||
7739 | TempA | |
7740 | ||
7741 | DEFINITIONS ::= | |
7742 | BEGIN | |
7743 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
7744 | ||
7745 | myIntegerValue BERPDU ::= -5 | |
7746 | ||
7747 | END | |
7748 | ||
7749 | <STATIC> | |
7750 | ||
7751 | import from TempA all; | |
7752 | ||
7753 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7754 | ||
7755 | ||
7756 | <TTCN_TC:EXEC> | |
7757 | ||
7758 | if (dec_BER_PDU('E181030201FB'O) == myIntegerValue) | |
7759 | ||
7760 | ||
7761 | {setverdict(pass);} else {setverdict(fail);} | |
7762 | ||
7763 | ||
7764 | <RESULT> | |
7765 | ||
7766 | Overall verdict: pass | |
7767 | ||
7768 | <END_TC> | |
7769 | ||
7770 | :exmp. | |
7771 | ||
7772 | .*---------------------------------------------------------------------* | |
7773 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Long form Long form | |
7774 | .*---------------------------------------------------------------------* | |
7775 | :xmp tab=0. | |
7776 | ||
7777 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5), Long form Long form> | |
7778 | ||
7779 | <STATIC:ASN> | |
7780 | ||
7781 | TempA | |
7782 | ||
7783 | DEFINITIONS ::= | |
7784 | BEGIN | |
7785 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
7786 | ||
7787 | myIntegerValue BERPDU ::= -5 | |
7788 | ||
7789 | END | |
7790 | ||
7791 | <STATIC> | |
7792 | ||
7793 | import from TempA all; | |
7794 | ||
7795 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7796 | ||
7797 | ||
7798 | <TTCN_TC:EXEC> | |
7799 | ||
7800 | if (dec_BER_PDU('E18104028101FB'O) == myIntegerValue) | |
7801 | ||
7802 | ||
7803 | {setverdict(pass);} else {setverdict(fail);} | |
7804 | ||
7805 | ||
7806 | <RESULT> | |
7807 | ||
7808 | Overall verdict: pass | |
7809 | ||
7810 | <END_TC> | |
7811 | ||
7812 | :exmp. | |
7813 | ||
7814 | .*---------------------------------------------------------------------* | |
7815 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-5),Indefinite form,CER | |
7816 | .*---------------------------------------------------------------------* | |
7817 | :xmp tab=0. | |
7818 | ||
7819 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-5),Indefinite form,CER> | |
7820 | ||
7821 | <STATIC:ASN> | |
7822 | ||
7823 | TempA | |
7824 | ||
7825 | DEFINITIONS ::= | |
7826 | BEGIN | |
7827 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
7828 | ||
7829 | myIntegerValue BERPDU ::= -5 | |
7830 | ||
7831 | END | |
7832 | ||
7833 | <STATIC> | |
7834 | ||
7835 | import from TempA all; | |
7836 | ||
7837 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7838 | ||
7839 | ||
7840 | <TTCN_TC:EXEC> | |
7841 | ||
7842 | if (dec_BER_PDU('E1800201FB0000'O) == myIntegerValue) | |
7843 | ||
7844 | ||
7845 | {setverdict(pass);} else {setverdict(fail);} | |
7846 | ||
7847 | ||
7848 | <RESULT> | |
7849 | ||
7850 | Overall verdict: pass | |
7851 | ||
7852 | <END_TC> | |
7853 | ||
7854 | :exmp. | |
7855 | ||
7856 | .*---------------------------------------------------------------------* | |
7857 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Short form - Short form, DER | |
7858 | .*---------------------------------------------------------------------* | |
7859 | :xmp tab=0. | |
7860 | ||
7861 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Short form - Short form, DER> | |
7862 | ||
7863 | <STATIC:ASN> | |
7864 | ||
7865 | TempA | |
7866 | ||
7867 | DEFINITIONS ::= | |
7868 | BEGIN | |
7869 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
7870 | ||
7871 | myIntegerValue BERPDU ::= -5 | |
7872 | ||
7873 | END | |
7874 | ||
7875 | <STATIC> | |
7876 | ||
7877 | import from TempA all; | |
7878 | ||
7879 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7880 | ||
7881 | ||
7882 | <TTCN_TC:EXEC> | |
7883 | ||
7884 | if (dec_BER_PDU('62030201FB'O) == myIntegerValue) | |
7885 | ||
7886 | ||
7887 | {setverdict(pass);} else {setverdict(fail);} | |
7888 | ||
7889 | ||
7890 | <RESULT> | |
7891 | ||
7892 | Overall verdict: pass | |
7893 | ||
7894 | <END_TC> | |
7895 | ||
7896 | :exmp. | |
7897 | ||
7898 | .*---------------------------------------------------------------------* | |
7899 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Short form - long form | |
7900 | .*---------------------------------------------------------------------* | |
7901 | :xmp tab=0. | |
7902 | ||
7903 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Short form - long form> | |
7904 | ||
7905 | <STATIC:ASN> | |
7906 | ||
7907 | TempA | |
7908 | ||
7909 | DEFINITIONS ::= | |
7910 | BEGIN | |
7911 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
7912 | ||
7913 | myIntegerValue BERPDU ::= -5 | |
7914 | ||
7915 | END | |
7916 | ||
7917 | <STATIC> | |
7918 | ||
7919 | import from TempA all; | |
7920 | ||
7921 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7922 | ||
7923 | ||
7924 | <TTCN_TC:EXEC> | |
7925 | ||
7926 | if (dec_BER_PDU('6204028101FB'O) == myIntegerValue) | |
7927 | ||
7928 | ||
7929 | {setverdict(pass);} else {setverdict(fail);} | |
7930 | ||
7931 | ||
7932 | <RESULT> | |
7933 | ||
7934 | Overall verdict: pass | |
7935 | ||
7936 | <END_TC> | |
7937 | ||
7938 | :exmp. | |
7939 | ||
7940 | .*---------------------------------------------------------------------* | |
7941 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Long form - short form | |
7942 | .*---------------------------------------------------------------------* | |
7943 | :xmp tab=0. | |
7944 | ||
7945 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Long form - short form> | |
7946 | ||
7947 | <STATIC:ASN> | |
7948 | ||
7949 | TempA | |
7950 | ||
7951 | DEFINITIONS ::= | |
7952 | BEGIN | |
7953 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
7954 | ||
7955 | myIntegerValue BERPDU ::= -5 | |
7956 | ||
7957 | END | |
7958 | ||
7959 | <STATIC> | |
7960 | ||
7961 | import from TempA all; | |
7962 | ||
7963 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
7964 | ||
7965 | ||
7966 | <TTCN_TC:EXEC> | |
7967 | ||
7968 | if (dec_BER_PDU('6281030201FB'O) == myIntegerValue) | |
7969 | ||
7970 | ||
7971 | {setverdict(pass);} else {setverdict(fail);} | |
7972 | ||
7973 | ||
7974 | <RESULT> | |
7975 | ||
7976 | Overall verdict: pass | |
7977 | ||
7978 | <END_TC> | |
7979 | ||
7980 | :exmp. | |
7981 | ||
7982 | .*---------------------------------------------------------------------* | |
7983 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Long form Long form | |
7984 | .*---------------------------------------------------------------------* | |
7985 | :xmp tab=0. | |
7986 | ||
7987 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5), Long form Long form> | |
7988 | ||
7989 | <STATIC:ASN> | |
7990 | ||
7991 | TempA | |
7992 | ||
7993 | DEFINITIONS ::= | |
7994 | BEGIN | |
7995 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
7996 | ||
7997 | myIntegerValue BERPDU ::= -5 | |
7998 | ||
7999 | END | |
8000 | ||
8001 | <STATIC> | |
8002 | ||
8003 | import from TempA all; | |
8004 | ||
8005 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8006 | ||
8007 | ||
8008 | <TTCN_TC:EXEC> | |
8009 | ||
8010 | if (dec_BER_PDU('628104028101FB'O) == myIntegerValue) | |
8011 | ||
8012 | ||
8013 | {setverdict(pass);} else {setverdict(fail);} | |
8014 | ||
8015 | ||
8016 | <RESULT> | |
8017 | ||
8018 | Overall verdict: pass | |
8019 | ||
8020 | <END_TC> | |
8021 | ||
8022 | :exmp. | |
8023 | ||
8024 | .*---------------------------------------------------------------------* | |
8025 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-5),Indefinite form,CER | |
8026 | .*---------------------------------------------------------------------* | |
8027 | :xmp tab=0. | |
8028 | ||
8029 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-5),Indefinite form,CER> | |
8030 | ||
8031 | <STATIC:ASN> | |
8032 | ||
8033 | TempA | |
8034 | ||
8035 | DEFINITIONS ::= | |
8036 | BEGIN | |
8037 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
8038 | ||
8039 | myIntegerValue BERPDU ::= -5 | |
8040 | ||
8041 | END | |
8042 | ||
8043 | <STATIC> | |
8044 | ||
8045 | import from TempA all; | |
8046 | ||
8047 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8048 | ||
8049 | ||
8050 | <TTCN_TC:EXEC> | |
8051 | ||
8052 | if (dec_BER_PDU('62800201FB0000'O) == myIntegerValue) | |
8053 | ||
8054 | ||
8055 | {setverdict(pass);} else {setverdict(fail);} | |
8056 | ||
8057 | ||
8058 | <RESULT> | |
8059 | ||
8060 | Overall verdict: pass | |
8061 | ||
8062 | <END_TC> | |
8063 | ||
8064 | :exmp. | |
8065 | ||
8066 | .*---------------------------------------------------------------------* | |
8067 | :h3. DECODING [0] IMPLICIT INTEGER (-5),Short form CER,DER | |
8068 | .*---------------------------------------------------------------------* | |
8069 | :xmp tab=0. | |
8070 | ||
8071 | <TC - DECODING [0] IMPLICIT INTEGER (-5),Short form CER,DER> | |
8072 | ||
8073 | <STATIC:ASN> | |
8074 | ||
8075 | TempA | |
8076 | ||
8077 | DEFINITIONS ::= | |
8078 | BEGIN | |
8079 | BERPDU ::= [0] IMPLICIT INTEGER | |
8080 | ||
8081 | myIntegerValue BERPDU ::= -5 | |
8082 | ||
8083 | END | |
8084 | ||
8085 | <STATIC> | |
8086 | ||
8087 | import from TempA all; | |
8088 | ||
8089 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8090 | ||
8091 | ||
8092 | <TTCN_TC:EXEC> | |
8093 | ||
8094 | if (dec_BER_PDU('8001FB'O) == myIntegerValue) | |
8095 | ||
8096 | ||
8097 | {setverdict(pass);} else {setverdict(fail);} | |
8098 | ||
8099 | ||
8100 | <RESULT> | |
8101 | ||
8102 | Overall verdict: pass | |
8103 | ||
8104 | <END_TC> | |
8105 | ||
8106 | :exmp. | |
8107 | ||
8108 | .*---------------------------------------------------------------------* | |
8109 | :h3. DECODING [0] IMPLICIT INTEGER (-5),Long form | |
8110 | .*---------------------------------------------------------------------* | |
8111 | :xmp tab=0. | |
8112 | ||
8113 | <TC - DECODING [0] IMPLICIT INTEGER (-5),Long form> | |
8114 | ||
8115 | <STATIC:ASN> | |
8116 | ||
8117 | TempA | |
8118 | ||
8119 | DEFINITIONS ::= | |
8120 | BEGIN | |
8121 | BERPDU ::= [0] IMPLICIT INTEGER | |
8122 | ||
8123 | myIntegerValue BERPDU ::= -5 | |
8124 | ||
8125 | END | |
8126 | ||
8127 | <STATIC> | |
8128 | ||
8129 | import from TempA all; | |
8130 | ||
8131 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8132 | ||
8133 | ||
8134 | <TTCN_TC:EXEC> | |
8135 | ||
8136 | if (dec_BER_PDU('808101FB'O) == myIntegerValue) | |
8137 | ||
8138 | ||
8139 | {setverdict(pass);} else {setverdict(fail);} | |
8140 | ||
8141 | ||
8142 | <RESULT> | |
8143 | ||
8144 | Overall verdict: pass | |
8145 | ||
8146 | <END_TC> | |
8147 | ||
8148 | :exmp. | |
8149 | ||
8150 | .*---------------------------------------------------------------------* | |
8151 | :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-5),Short form CER,DER | |
8152 | .*---------------------------------------------------------------------* | |
8153 | :xmp tab=0. | |
8154 | ||
8155 | <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-5),Short form CER,DER> | |
8156 | ||
8157 | <STATIC:ASN> | |
8158 | ||
8159 | TempA | |
8160 | ||
8161 | DEFINITIONS ::= | |
8162 | BEGIN | |
8163 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
8164 | ||
8165 | myIntegerValue BERPDU ::= -5 | |
8166 | ||
8167 | END | |
8168 | ||
8169 | <STATIC> | |
8170 | ||
8171 | import from TempA all; | |
8172 | ||
8173 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8174 | ||
8175 | ||
8176 | <TTCN_TC:EXEC> | |
8177 | ||
8178 | if (dec_BER_PDU('C101FB'O) == myIntegerValue) | |
8179 | ||
8180 | ||
8181 | {setverdict(pass);} else {setverdict(fail);} | |
8182 | ||
8183 | ||
8184 | <RESULT> | |
8185 | ||
8186 | Overall verdict: pass | |
8187 | ||
8188 | <END_TC> | |
8189 | ||
8190 | :exmp. | |
8191 | ||
8192 | .*---------------------------------------------------------------------* | |
8193 | :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-5),Long form | |
8194 | .*---------------------------------------------------------------------* | |
8195 | :xmp tab=0. | |
8196 | ||
8197 | <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-5),Long form> | |
8198 | ||
8199 | <STATIC:ASN> | |
8200 | ||
8201 | TempA | |
8202 | ||
8203 | DEFINITIONS ::= | |
8204 | BEGIN | |
8205 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
8206 | ||
8207 | myIntegerValue BERPDU ::= -5 | |
8208 | ||
8209 | END | |
8210 | ||
8211 | <STATIC> | |
8212 | ||
8213 | import from TempA all; | |
8214 | ||
8215 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8216 | ||
8217 | ||
8218 | <TTCN_TC:EXEC> | |
8219 | ||
8220 | if (dec_BER_PDU('C18101FB'O) == myIntegerValue) | |
8221 | ||
8222 | ||
8223 | {setverdict(pass);} else {setverdict(fail);} | |
8224 | ||
8225 | ||
8226 | <RESULT> | |
8227 | ||
8228 | Overall verdict: pass | |
8229 | ||
8230 | <END_TC> | |
8231 | ||
8232 | :exmp. | |
8233 | ||
8234 | .*---------------------------------------------------------------------* | |
8235 | :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-5),Short form CER,DER | |
8236 | .*---------------------------------------------------------------------* | |
8237 | :xmp tab=0. | |
8238 | ||
8239 | <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-5),Short form CER,DER> | |
8240 | ||
8241 | <STATIC:ASN> | |
8242 | ||
8243 | TempA | |
8244 | ||
8245 | DEFINITIONS ::= | |
8246 | BEGIN | |
8247 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
8248 | ||
8249 | myIntegerValue BERPDU ::= -5 | |
8250 | ||
8251 | END | |
8252 | ||
8253 | <STATIC> | |
8254 | ||
8255 | import from TempA all; | |
8256 | ||
8257 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8258 | ||
8259 | ||
8260 | <TTCN_TC:EXEC> | |
8261 | ||
8262 | if (dec_BER_PDU('4201FB'O) == myIntegerValue) | |
8263 | ||
8264 | ||
8265 | {setverdict(pass);} else {setverdict(fail);} | |
8266 | ||
8267 | ||
8268 | <RESULT> | |
8269 | ||
8270 | Overall verdict: pass | |
8271 | ||
8272 | <END_TC> | |
8273 | ||
8274 | :exmp. | |
8275 | ||
8276 | .*---------------------------------------------------------------------* | |
8277 | :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-5),Long form | |
8278 | .*---------------------------------------------------------------------* | |
8279 | :xmp tab=0. | |
8280 | ||
8281 | <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-5),Long form> | |
8282 | ||
8283 | <STATIC:ASN> | |
8284 | ||
8285 | TempA | |
8286 | ||
8287 | DEFINITIONS ::= | |
8288 | BEGIN | |
8289 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
8290 | ||
8291 | myIntegerValue BERPDU ::= -5 | |
8292 | ||
8293 | END | |
8294 | ||
8295 | <STATIC> | |
8296 | ||
8297 | import from TempA all; | |
8298 | ||
8299 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8300 | ||
8301 | ||
8302 | <TTCN_TC:EXEC> | |
8303 | ||
8304 | if (dec_BER_PDU('428101FB'O) == myIntegerValue) | |
8305 | ||
8306 | ||
8307 | {setverdict(pass);} else {setverdict(fail);} | |
8308 | ||
8309 | ||
8310 | <RESULT> | |
8311 | ||
8312 | Overall verdict: pass | |
8313 | ||
8314 | <END_TC> | |
8315 | ||
8316 | :exmp. | |
8317 | ||
8318 | .*---------------------------------------------------------------------* | |
8319 | :h3. DECODING INTEGER (128), CER+DER | |
8320 | .*---------------------------------------------------------------------* | |
8321 | :xmp tab=0. | |
8322 | ||
8323 | <TC - DECODING INTEGER (128), CER+DER> | |
8324 | ||
8325 | <STATIC:ASN> | |
8326 | ||
8327 | TempA | |
8328 | ||
8329 | DEFINITIONS ::= | |
8330 | BEGIN | |
8331 | BERPDU ::= INTEGER | |
8332 | ||
8333 | myIntegerValue BERPDU ::= 128 | |
8334 | ||
8335 | END | |
8336 | ||
8337 | <STATIC> | |
8338 | ||
8339 | import from TempA all; | |
8340 | ||
8341 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8342 | ||
8343 | ||
8344 | <TTCN_TC:EXEC> | |
8345 | ||
8346 | if (dec_BER_PDU('02020080'O) == myIntegerValue) | |
8347 | ||
8348 | ||
8349 | {setverdict(pass);} else {setverdict(fail);} | |
8350 | ||
8351 | ||
8352 | <RESULT> | |
8353 | ||
8354 | Overall verdict: pass | |
8355 | ||
8356 | <END_TC> | |
8357 | ||
8358 | :exmp. | |
8359 | ||
8360 | .*---------------------------------------------------------------------* | |
8361 | :h3. DECODING INTEGER (128), (LENGTH OF LENGTH = 1) | |
8362 | .*---------------------------------------------------------------------* | |
8363 | :xmp tab=0. | |
8364 | ||
8365 | <TC - DECODING INTEGER (128), (LENGTH OF LENGTH = 1)> | |
8366 | ||
8367 | <STATIC:ASN> | |
8368 | ||
8369 | TempA | |
8370 | ||
8371 | DEFINITIONS ::= | |
8372 | BEGIN | |
8373 | BERPDU ::= INTEGER | |
8374 | ||
8375 | myIntegerValue BERPDU ::= 128 | |
8376 | ||
8377 | END | |
8378 | ||
8379 | <STATIC> | |
8380 | ||
8381 | import from TempA all; | |
8382 | ||
8383 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8384 | ||
8385 | ||
8386 | <TTCN_TC:EXEC> | |
8387 | ||
8388 | if (dec_BER_PDU('0281020080'O) == myIntegerValue) | |
8389 | ||
8390 | ||
8391 | {setverdict(pass);} else {setverdict(fail);} | |
8392 | ||
8393 | ||
8394 | <RESULT> | |
8395 | ||
8396 | Overall verdict: pass | |
8397 | ||
8398 | <END_TC> | |
8399 | ||
8400 | :exmp. | |
8401 | ||
8402 | .*---------------------------------------------------------------------* | |
8403 | :h3. DECODING INTEGER (128), (LENGTH OF LENGTH = 2) | |
8404 | .*---------------------------------------------------------------------* | |
8405 | :xmp tab=0. | |
8406 | ||
8407 | <TC - DECODING INTEGER (128), (LENGTH OF LENGTH = 2)> | |
8408 | ||
8409 | <STATIC:ASN> | |
8410 | ||
8411 | TempA | |
8412 | ||
8413 | DEFINITIONS ::= | |
8414 | BEGIN | |
8415 | BERPDU ::= INTEGER | |
8416 | ||
8417 | myIntegerValue BERPDU ::= 128 | |
8418 | ||
8419 | END | |
8420 | ||
8421 | <STATIC> | |
8422 | ||
8423 | import from TempA all; | |
8424 | ||
8425 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8426 | ||
8427 | ||
8428 | <TTCN_TC:EXEC> | |
8429 | ||
8430 | if (dec_BER_PDU('028200020080'O) == myIntegerValue) | |
8431 | ||
8432 | ||
8433 | {setverdict(pass);} else {setverdict(fail);} | |
8434 | ||
8435 | ||
8436 | <RESULT> | |
8437 | ||
8438 | Overall verdict: pass | |
8439 | ||
8440 | <END_TC> | |
8441 | ||
8442 | :exmp. | |
8443 | ||
8444 | .*---------------------------------------------------------------------* | |
8445 | :h3. DECODING [0] EXPLICIT INTEGER (128), DER | |
8446 | .*---------------------------------------------------------------------* | |
8447 | :xmp tab=0. | |
8448 | ||
8449 | <TC - DECODING [0] EXPLICIT INTEGER (128), DER> | |
8450 | ||
8451 | <STATIC:ASN> | |
8452 | ||
8453 | TempA | |
8454 | ||
8455 | DEFINITIONS ::= | |
8456 | BEGIN | |
8457 | BERPDU ::= [0] EXPLICIT INTEGER | |
8458 | ||
8459 | myIntegerValue BERPDU ::= 128 | |
8460 | ||
8461 | END | |
8462 | ||
8463 | <STATIC> | |
8464 | ||
8465 | import from TempA all; | |
8466 | ||
8467 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8468 | ||
8469 | ||
8470 | <TTCN_TC:EXEC> | |
8471 | ||
8472 | if (dec_BER_PDU('A00402020080'O) == myIntegerValue) | |
8473 | ||
8474 | ||
8475 | {setverdict(pass);} else {setverdict(fail);} | |
8476 | ||
8477 | ||
8478 | <RESULT> | |
8479 | ||
8480 | Overall verdict: pass | |
8481 | ||
8482 | <END_TC> | |
8483 | ||
8484 | :exmp. | |
8485 | ||
8486 | .*---------------------------------------------------------------------* | |
8487 | :h3. DECODING [0] EXPLICIT INTEGER (128), CER | |
8488 | .*---------------------------------------------------------------------* | |
8489 | :xmp tab=0. | |
8490 | ||
8491 | <TC - DECODING [0] EXPLICIT INTEGER (128), CER> | |
8492 | ||
8493 | <STATIC:ASN> | |
8494 | ||
8495 | TempA | |
8496 | ||
8497 | DEFINITIONS ::= | |
8498 | BEGIN | |
8499 | BERPDU ::= [0] EXPLICIT INTEGER | |
8500 | ||
8501 | myIntegerValue BERPDU ::= 128 | |
8502 | ||
8503 | END | |
8504 | ||
8505 | <STATIC> | |
8506 | ||
8507 | import from TempA all; | |
8508 | ||
8509 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8510 | ||
8511 | ||
8512 | <TTCN_TC:EXEC> | |
8513 | ||
8514 | if (dec_BER_PDU('A080020200800000'O) == myIntegerValue) | |
8515 | ||
8516 | ||
8517 | {setverdict(pass);} else {setverdict(fail);} | |
8518 | ||
8519 | ||
8520 | <RESULT> | |
8521 | ||
8522 | Overall verdict: pass | |
8523 | ||
8524 | <END_TC> | |
8525 | ||
8526 | :exmp. | |
8527 | ||
8528 | .*---------------------------------------------------------------------* | |
8529 | :h3. DECODING [0] EXPLICIT INTEGER (128), Short form - long form | |
8530 | .*---------------------------------------------------------------------* | |
8531 | :xmp tab=0. | |
8532 | ||
8533 | <TC - DECODING [0] EXPLICIT INTEGER (128), Short form - long form> | |
8534 | ||
8535 | <STATIC:ASN> | |
8536 | ||
8537 | TempA | |
8538 | ||
8539 | DEFINITIONS ::= | |
8540 | BEGIN | |
8541 | BERPDU ::= [0] EXPLICIT INTEGER | |
8542 | ||
8543 | myIntegerValue BERPDU ::= 128 | |
8544 | ||
8545 | END | |
8546 | ||
8547 | <STATIC> | |
8548 | ||
8549 | import from TempA all; | |
8550 | ||
8551 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8552 | ||
8553 | ||
8554 | <TTCN_TC:EXEC> | |
8555 | ||
8556 | if (dec_BER_PDU('A00402020080'O) == myIntegerValue) | |
8557 | ||
8558 | ||
8559 | {setverdict(pass);} else {setverdict(fail);} | |
8560 | ||
8561 | ||
8562 | <RESULT> | |
8563 | ||
8564 | Overall verdict: pass | |
8565 | ||
8566 | <END_TC> | |
8567 | ||
8568 | :exmp. | |
8569 | ||
8570 | .*---------------------------------------------------------------------* | |
8571 | :h3. DECODING [0] EXPLICIT INTEGER (128), Long form - short form | |
8572 | .*---------------------------------------------------------------------* | |
8573 | :xmp tab=0. | |
8574 | ||
8575 | <TC - DECODING [0] EXPLICIT INTEGER (128), Long form - short form> | |
8576 | ||
8577 | <STATIC:ASN> | |
8578 | ||
8579 | TempA | |
8580 | ||
8581 | DEFINITIONS ::= | |
8582 | BEGIN | |
8583 | BERPDU ::= [0] EXPLICIT INTEGER | |
8584 | ||
8585 | myIntegerValue BERPDU ::= 128 | |
8586 | ||
8587 | END | |
8588 | ||
8589 | <STATIC> | |
8590 | ||
8591 | import from TempA all; | |
8592 | ||
8593 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8594 | ||
8595 | ||
8596 | <TTCN_TC:EXEC> | |
8597 | ||
8598 | if (dec_BER_PDU('A0810402020080'O) == myIntegerValue) | |
8599 | ||
8600 | ||
8601 | {setverdict(pass);} else {setverdict(fail);} | |
8602 | ||
8603 | ||
8604 | <RESULT> | |
8605 | ||
8606 | Overall verdict: pass | |
8607 | ||
8608 | <END_TC> | |
8609 | ||
8610 | :exmp. | |
8611 | ||
8612 | .*---------------------------------------------------------------------* | |
8613 | :h3. DECODING [0] EXPLICIT INTEGER (128), Long form Long form | |
8614 | .*---------------------------------------------------------------------* | |
8615 | :xmp tab=0. | |
8616 | ||
8617 | <TC - DECODING [0] EXPLICIT INTEGER (128), Long form Long form> | |
8618 | ||
8619 | <STATIC:ASN> | |
8620 | ||
8621 | TempA | |
8622 | ||
8623 | DEFINITIONS ::= | |
8624 | BEGIN | |
8625 | BERPDU ::= [0] EXPLICIT INTEGER | |
8626 | ||
8627 | myIntegerValue BERPDU ::= 128 | |
8628 | ||
8629 | END | |
8630 | ||
8631 | <STATIC> | |
8632 | ||
8633 | import from TempA all; | |
8634 | ||
8635 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8636 | ||
8637 | ||
8638 | <TTCN_TC:EXEC> | |
8639 | ||
8640 | if (dec_BER_PDU('A081050281020080'O) == myIntegerValue) | |
8641 | ||
8642 | ||
8643 | {setverdict(pass);} else {setverdict(fail);} | |
8644 | ||
8645 | ||
8646 | <RESULT> | |
8647 | ||
8648 | Overall verdict: pass | |
8649 | ||
8650 | <END_TC> | |
8651 | ||
8652 | :exmp. | |
8653 | ||
8654 | .*---------------------------------------------------------------------* | |
8655 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Short form - Short form, DER | |
8656 | .*---------------------------------------------------------------------* | |
8657 | :xmp tab=0. | |
8658 | ||
8659 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Short form - Short form, DER> | |
8660 | ||
8661 | <STATIC:ASN> | |
8662 | ||
8663 | TempA | |
8664 | ||
8665 | DEFINITIONS ::= | |
8666 | BEGIN | |
8667 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
8668 | ||
8669 | myIntegerValue BERPDU ::= 128 | |
8670 | ||
8671 | END | |
8672 | ||
8673 | <STATIC> | |
8674 | ||
8675 | import from TempA all; | |
8676 | ||
8677 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8678 | ||
8679 | ||
8680 | <TTCN_TC:EXEC> | |
8681 | ||
8682 | if (dec_BER_PDU('E10402020080'O) == myIntegerValue) | |
8683 | ||
8684 | ||
8685 | {setverdict(pass);} else {setverdict(fail);} | |
8686 | ||
8687 | ||
8688 | <RESULT> | |
8689 | ||
8690 | Overall verdict: pass | |
8691 | ||
8692 | <END_TC> | |
8693 | ||
8694 | :exmp. | |
8695 | ||
8696 | .*---------------------------------------------------------------------* | |
8697 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Short form - long form | |
8698 | .*---------------------------------------------------------------------* | |
8699 | :xmp tab=0. | |
8700 | ||
8701 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Short form - long form> | |
8702 | ||
8703 | <STATIC:ASN> | |
8704 | ||
8705 | TempA | |
8706 | ||
8707 | DEFINITIONS ::= | |
8708 | BEGIN | |
8709 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
8710 | ||
8711 | myIntegerValue BERPDU ::= 128 | |
8712 | ||
8713 | END | |
8714 | ||
8715 | <STATIC> | |
8716 | ||
8717 | import from TempA all; | |
8718 | ||
8719 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8720 | ||
8721 | ||
8722 | <TTCN_TC:EXEC> | |
8723 | ||
8724 | if (dec_BER_PDU('E1050281020080'O) == myIntegerValue) | |
8725 | ||
8726 | ||
8727 | {setverdict(pass);} else {setverdict(fail);} | |
8728 | ||
8729 | ||
8730 | <RESULT> | |
8731 | ||
8732 | Overall verdict: pass | |
8733 | ||
8734 | <END_TC> | |
8735 | ||
8736 | :exmp. | |
8737 | ||
8738 | .*---------------------------------------------------------------------* | |
8739 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Long form - short form | |
8740 | .*---------------------------------------------------------------------* | |
8741 | :xmp tab=0. | |
8742 | ||
8743 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Long form - short form> | |
8744 | ||
8745 | <STATIC:ASN> | |
8746 | ||
8747 | TempA | |
8748 | ||
8749 | DEFINITIONS ::= | |
8750 | BEGIN | |
8751 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
8752 | ||
8753 | myIntegerValue BERPDU ::= 128 | |
8754 | ||
8755 | END | |
8756 | ||
8757 | <STATIC> | |
8758 | ||
8759 | import from TempA all; | |
8760 | ||
8761 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8762 | ||
8763 | ||
8764 | <TTCN_TC:EXEC> | |
8765 | ||
8766 | if (dec_BER_PDU('E1810402020080'O) == myIntegerValue) | |
8767 | ||
8768 | ||
8769 | {setverdict(pass);} else {setverdict(fail);} | |
8770 | ||
8771 | ||
8772 | <RESULT> | |
8773 | ||
8774 | Overall verdict: pass | |
8775 | ||
8776 | <END_TC> | |
8777 | ||
8778 | :exmp. | |
8779 | ||
8780 | .*---------------------------------------------------------------------* | |
8781 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Long form Long form | |
8782 | .*---------------------------------------------------------------------* | |
8783 | :xmp tab=0. | |
8784 | ||
8785 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128), Long form Long form> | |
8786 | ||
8787 | <STATIC:ASN> | |
8788 | ||
8789 | TempA | |
8790 | ||
8791 | DEFINITIONS ::= | |
8792 | BEGIN | |
8793 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
8794 | ||
8795 | myIntegerValue BERPDU ::= 128 | |
8796 | ||
8797 | END | |
8798 | ||
8799 | <STATIC> | |
8800 | ||
8801 | import from TempA all; | |
8802 | ||
8803 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8804 | ||
8805 | ||
8806 | <TTCN_TC:EXEC> | |
8807 | ||
8808 | if (dec_BER_PDU('E181050281020080'O) == myIntegerValue) | |
8809 | ||
8810 | ||
8811 | {setverdict(pass);} else {setverdict(fail);} | |
8812 | ||
8813 | ||
8814 | <RESULT> | |
8815 | ||
8816 | Overall verdict: pass | |
8817 | ||
8818 | <END_TC> | |
8819 | ||
8820 | :exmp. | |
8821 | ||
8822 | .*---------------------------------------------------------------------* | |
8823 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (128),Indefinite form,CER | |
8824 | .*---------------------------------------------------------------------* | |
8825 | :xmp tab=0. | |
8826 | ||
8827 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (128),Indefinite form,CER> | |
8828 | ||
8829 | <STATIC:ASN> | |
8830 | ||
8831 | TempA | |
8832 | ||
8833 | DEFINITIONS ::= | |
8834 | BEGIN | |
8835 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
8836 | ||
8837 | myIntegerValue BERPDU ::= 128 | |
8838 | ||
8839 | END | |
8840 | ||
8841 | <STATIC> | |
8842 | ||
8843 | import from TempA all; | |
8844 | ||
8845 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8846 | ||
8847 | ||
8848 | <TTCN_TC:EXEC> | |
8849 | ||
8850 | if (dec_BER_PDU('E180020200800000'O) == myIntegerValue) | |
8851 | ||
8852 | ||
8853 | {setverdict(pass);} else {setverdict(fail);} | |
8854 | ||
8855 | ||
8856 | <RESULT> | |
8857 | ||
8858 | Overall verdict: pass | |
8859 | ||
8860 | <END_TC> | |
8861 | ||
8862 | :exmp. | |
8863 | ||
8864 | .*---------------------------------------------------------------------* | |
8865 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Short form - Short form, DER | |
8866 | .*---------------------------------------------------------------------* | |
8867 | :xmp tab=0. | |
8868 | ||
8869 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Short form - Short form, DER> | |
8870 | ||
8871 | <STATIC:ASN> | |
8872 | ||
8873 | TempA | |
8874 | ||
8875 | DEFINITIONS ::= | |
8876 | BEGIN | |
8877 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
8878 | ||
8879 | myIntegerValue BERPDU ::= 128 | |
8880 | ||
8881 | END | |
8882 | ||
8883 | <STATIC> | |
8884 | ||
8885 | import from TempA all; | |
8886 | ||
8887 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8888 | ||
8889 | ||
8890 | <TTCN_TC:EXEC> | |
8891 | ||
8892 | if (dec_BER_PDU('620402020080'O) == myIntegerValue) | |
8893 | ||
8894 | ||
8895 | {setverdict(pass);} else {setverdict(fail);} | |
8896 | ||
8897 | ||
8898 | <RESULT> | |
8899 | ||
8900 | Overall verdict: pass | |
8901 | ||
8902 | <END_TC> | |
8903 | ||
8904 | :exmp. | |
8905 | ||
8906 | .*---------------------------------------------------------------------* | |
8907 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Short form - long form | |
8908 | .*---------------------------------------------------------------------* | |
8909 | :xmp tab=0. | |
8910 | ||
8911 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Short form - long form> | |
8912 | ||
8913 | <STATIC:ASN> | |
8914 | ||
8915 | TempA | |
8916 | ||
8917 | DEFINITIONS ::= | |
8918 | BEGIN | |
8919 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
8920 | ||
8921 | myIntegerValue BERPDU ::= 128 | |
8922 | ||
8923 | END | |
8924 | ||
8925 | <STATIC> | |
8926 | ||
8927 | import from TempA all; | |
8928 | ||
8929 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8930 | ||
8931 | ||
8932 | <TTCN_TC:EXEC> | |
8933 | ||
8934 | if (dec_BER_PDU('62050281020080'O) == myIntegerValue) | |
8935 | ||
8936 | ||
8937 | {setverdict(pass);} else {setverdict(fail);} | |
8938 | ||
8939 | ||
8940 | <RESULT> | |
8941 | ||
8942 | Overall verdict: pass | |
8943 | ||
8944 | <END_TC> | |
8945 | ||
8946 | :exmp. | |
8947 | ||
8948 | .*---------------------------------------------------------------------* | |
8949 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Long form - short form | |
8950 | .*---------------------------------------------------------------------* | |
8951 | :xmp tab=0. | |
8952 | ||
8953 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Long form - short form> | |
8954 | ||
8955 | <STATIC:ASN> | |
8956 | ||
8957 | TempA | |
8958 | ||
8959 | DEFINITIONS ::= | |
8960 | BEGIN | |
8961 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
8962 | ||
8963 | myIntegerValue BERPDU ::= 128 | |
8964 | ||
8965 | END | |
8966 | ||
8967 | <STATIC> | |
8968 | ||
8969 | import from TempA all; | |
8970 | ||
8971 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
8972 | ||
8973 | ||
8974 | <TTCN_TC:EXEC> | |
8975 | ||
8976 | if (dec_BER_PDU('62810402020080'O) == myIntegerValue) | |
8977 | ||
8978 | ||
8979 | {setverdict(pass);} else {setverdict(fail);} | |
8980 | ||
8981 | ||
8982 | <RESULT> | |
8983 | ||
8984 | Overall verdict: pass | |
8985 | ||
8986 | <END_TC> | |
8987 | ||
8988 | :exmp. | |
8989 | ||
8990 | .*---------------------------------------------------------------------* | |
8991 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Long form Long form | |
8992 | .*---------------------------------------------------------------------* | |
8993 | :xmp tab=0. | |
8994 | ||
8995 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128), Long form Long form> | |
8996 | ||
8997 | <STATIC:ASN> | |
8998 | ||
8999 | TempA | |
9000 | ||
9001 | DEFINITIONS ::= | |
9002 | BEGIN | |
9003 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
9004 | ||
9005 | myIntegerValue BERPDU ::= 128 | |
9006 | ||
9007 | END | |
9008 | ||
9009 | <STATIC> | |
9010 | ||
9011 | import from TempA all; | |
9012 | ||
9013 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9014 | ||
9015 | ||
9016 | <TTCN_TC:EXEC> | |
9017 | ||
9018 | if (dec_BER_PDU('6281050281020080'O) == myIntegerValue) | |
9019 | ||
9020 | ||
9021 | {setverdict(pass);} else {setverdict(fail);} | |
9022 | ||
9023 | ||
9024 | <RESULT> | |
9025 | ||
9026 | Overall verdict: pass | |
9027 | ||
9028 | <END_TC> | |
9029 | ||
9030 | :exmp. | |
9031 | ||
9032 | .*---------------------------------------------------------------------* | |
9033 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (128),Indefinite form,CER | |
9034 | .*---------------------------------------------------------------------* | |
9035 | :xmp tab=0. | |
9036 | ||
9037 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (128),Indefinite form,CER> | |
9038 | ||
9039 | <STATIC:ASN> | |
9040 | ||
9041 | TempA | |
9042 | ||
9043 | DEFINITIONS ::= | |
9044 | BEGIN | |
9045 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
9046 | ||
9047 | myIntegerValue BERPDU ::= 128 | |
9048 | ||
9049 | END | |
9050 | ||
9051 | <STATIC> | |
9052 | ||
9053 | import from TempA all; | |
9054 | ||
9055 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9056 | ||
9057 | ||
9058 | <TTCN_TC:EXEC> | |
9059 | ||
9060 | if (dec_BER_PDU('6280020200800000'O) == myIntegerValue) | |
9061 | ||
9062 | ||
9063 | {setverdict(pass);} else {setverdict(fail);} | |
9064 | ||
9065 | ||
9066 | <RESULT> | |
9067 | ||
9068 | Overall verdict: pass | |
9069 | ||
9070 | <END_TC> | |
9071 | ||
9072 | :exmp. | |
9073 | ||
9074 | .*---------------------------------------------------------------------* | |
9075 | :h3. DECODING [0] IMPLICIT INTEGER (128),Short form CER,DER | |
9076 | .*---------------------------------------------------------------------* | |
9077 | :xmp tab=0. | |
9078 | ||
9079 | <TC - DECODING [0] IMPLICIT INTEGER (128),Short form CER,DER> | |
9080 | ||
9081 | <STATIC:ASN> | |
9082 | ||
9083 | TempA | |
9084 | ||
9085 | DEFINITIONS ::= | |
9086 | BEGIN | |
9087 | BERPDU ::= [0] IMPLICIT INTEGER | |
9088 | ||
9089 | myIntegerValue BERPDU ::= 128 | |
9090 | ||
9091 | END | |
9092 | ||
9093 | <STATIC> | |
9094 | ||
9095 | import from TempA all; | |
9096 | ||
9097 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9098 | ||
9099 | ||
9100 | <TTCN_TC:EXEC> | |
9101 | ||
9102 | if (dec_BER_PDU('80020080'O) == myIntegerValue) | |
9103 | ||
9104 | ||
9105 | {setverdict(pass);} else {setverdict(fail);} | |
9106 | ||
9107 | ||
9108 | <RESULT> | |
9109 | ||
9110 | Overall verdict: pass | |
9111 | ||
9112 | <END_TC> | |
9113 | ||
9114 | :exmp. | |
9115 | ||
9116 | .*---------------------------------------------------------------------* | |
9117 | :h3. DECODING [0] IMPLICIT INTEGER (128),Long form | |
9118 | .*---------------------------------------------------------------------* | |
9119 | :xmp tab=0. | |
9120 | ||
9121 | <TC - DECODING [0] IMPLICIT INTEGER (128),Long form> | |
9122 | ||
9123 | <STATIC:ASN> | |
9124 | ||
9125 | TempA | |
9126 | ||
9127 | DEFINITIONS ::= | |
9128 | BEGIN | |
9129 | BERPDU ::= [0] IMPLICIT INTEGER | |
9130 | ||
9131 | myIntegerValue BERPDU ::= 128 | |
9132 | ||
9133 | END | |
9134 | ||
9135 | <STATIC> | |
9136 | ||
9137 | import from TempA all; | |
9138 | ||
9139 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9140 | ||
9141 | ||
9142 | <TTCN_TC:EXEC> | |
9143 | ||
9144 | if (dec_BER_PDU('8081020080'O) == myIntegerValue) | |
9145 | ||
9146 | ||
9147 | {setverdict(pass);} else {setverdict(fail);} | |
9148 | ||
9149 | ||
9150 | <RESULT> | |
9151 | ||
9152 | Overall verdict: pass | |
9153 | ||
9154 | <END_TC> | |
9155 | ||
9156 | :exmp. | |
9157 | ||
9158 | .*---------------------------------------------------------------------* | |
9159 | :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (128),Short form CER,DER | |
9160 | .*---------------------------------------------------------------------* | |
9161 | :xmp tab=0. | |
9162 | ||
9163 | <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (128),Short form CER,DER> | |
9164 | ||
9165 | <STATIC:ASN> | |
9166 | ||
9167 | TempA | |
9168 | ||
9169 | DEFINITIONS ::= | |
9170 | BEGIN | |
9171 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
9172 | ||
9173 | myIntegerValue BERPDU ::= 128 | |
9174 | ||
9175 | END | |
9176 | ||
9177 | <STATIC> | |
9178 | ||
9179 | import from TempA all; | |
9180 | ||
9181 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9182 | ||
9183 | ||
9184 | <TTCN_TC:EXEC> | |
9185 | ||
9186 | if (dec_BER_PDU('C1020080'O) == myIntegerValue) | |
9187 | ||
9188 | ||
9189 | {setverdict(pass);} else {setverdict(fail);} | |
9190 | ||
9191 | ||
9192 | <RESULT> | |
9193 | ||
9194 | Overall verdict: pass | |
9195 | ||
9196 | <END_TC> | |
9197 | ||
9198 | :exmp. | |
9199 | ||
9200 | .*---------------------------------------------------------------------* | |
9201 | :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (128),Long form | |
9202 | .*---------------------------------------------------------------------* | |
9203 | :xmp tab=0. | |
9204 | ||
9205 | <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (128),Long form> | |
9206 | ||
9207 | <STATIC:ASN> | |
9208 | ||
9209 | TempA | |
9210 | ||
9211 | DEFINITIONS ::= | |
9212 | BEGIN | |
9213 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
9214 | ||
9215 | myIntegerValue BERPDU ::= 128 | |
9216 | ||
9217 | END | |
9218 | ||
9219 | <STATIC> | |
9220 | ||
9221 | import from TempA all; | |
9222 | ||
9223 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9224 | ||
9225 | ||
9226 | <TTCN_TC:EXEC> | |
9227 | ||
9228 | if (dec_BER_PDU('C181020080'O) == myIntegerValue) | |
9229 | ||
9230 | ||
9231 | {setverdict(pass);} else {setverdict(fail);} | |
9232 | ||
9233 | ||
9234 | <RESULT> | |
9235 | ||
9236 | Overall verdict: pass | |
9237 | ||
9238 | <END_TC> | |
9239 | ||
9240 | :exmp. | |
9241 | ||
9242 | .*---------------------------------------------------------------------* | |
9243 | :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (128),Short form CER,DER | |
9244 | .*---------------------------------------------------------------------* | |
9245 | :xmp tab=0. | |
9246 | ||
9247 | <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (128),Short form CER,DER> | |
9248 | ||
9249 | <STATIC:ASN> | |
9250 | ||
9251 | TempA | |
9252 | ||
9253 | DEFINITIONS ::= | |
9254 | BEGIN | |
9255 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
9256 | ||
9257 | myIntegerValue BERPDU ::= 128 | |
9258 | ||
9259 | END | |
9260 | ||
9261 | <STATIC> | |
9262 | ||
9263 | import from TempA all; | |
9264 | ||
9265 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9266 | ||
9267 | ||
9268 | <TTCN_TC:EXEC> | |
9269 | ||
9270 | if (dec_BER_PDU('42020080'O) == myIntegerValue) | |
9271 | ||
9272 | ||
9273 | {setverdict(pass);} else {setverdict(fail);} | |
9274 | ||
9275 | ||
9276 | <RESULT> | |
9277 | ||
9278 | Overall verdict: pass | |
9279 | ||
9280 | <END_TC> | |
9281 | ||
9282 | :exmp. | |
9283 | ||
9284 | .*---------------------------------------------------------------------* | |
9285 | :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (128),Long form | |
9286 | .*---------------------------------------------------------------------* | |
9287 | :xmp tab=0. | |
9288 | ||
9289 | <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (128),Long form> | |
9290 | ||
9291 | <STATIC:ASN> | |
9292 | ||
9293 | TempA | |
9294 | ||
9295 | DEFINITIONS ::= | |
9296 | BEGIN | |
9297 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
9298 | ||
9299 | myIntegerValue BERPDU ::= 128 | |
9300 | ||
9301 | END | |
9302 | ||
9303 | <STATIC> | |
9304 | ||
9305 | import from TempA all; | |
9306 | ||
9307 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9308 | ||
9309 | ||
9310 | <TTCN_TC:EXEC> | |
9311 | ||
9312 | if (dec_BER_PDU('4281020080'O) == myIntegerValue) | |
9313 | ||
9314 | ||
9315 | {setverdict(pass);} else {setverdict(fail);} | |
9316 | ||
9317 | ||
9318 | <RESULT> | |
9319 | ||
9320 | Overall verdict: pass | |
9321 | ||
9322 | <END_TC> | |
9323 | ||
9324 | :exmp. | |
9325 | ||
9326 | .*---------------------------------------------------------------------* | |
9327 | :h3. DECODING INTEGER (-129), CER+DER | |
9328 | .*---------------------------------------------------------------------* | |
9329 | :xmp tab=0. | |
9330 | ||
9331 | <TC - DECODING INTEGER (-129), CER+DER> | |
9332 | ||
9333 | <STATIC:ASN> | |
9334 | ||
9335 | TempA | |
9336 | ||
9337 | DEFINITIONS ::= | |
9338 | BEGIN | |
9339 | BERPDU ::= INTEGER | |
9340 | ||
9341 | myIntegerValue BERPDU ::= -129 | |
9342 | ||
9343 | END | |
9344 | ||
9345 | <STATIC> | |
9346 | ||
9347 | import from TempA all; | |
9348 | ||
9349 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9350 | ||
9351 | ||
9352 | <TTCN_TC:EXEC> | |
9353 | ||
9354 | if (dec_BER_PDU('0202FF7F'O) == myIntegerValue) | |
9355 | ||
9356 | ||
9357 | {setverdict(pass);} else {setverdict(fail);} | |
9358 | ||
9359 | ||
9360 | <RESULT> | |
9361 | ||
9362 | Overall verdict: pass | |
9363 | ||
9364 | <END_TC> | |
9365 | ||
9366 | :exmp. | |
9367 | ||
9368 | .*---------------------------------------------------------------------* | |
9369 | :h3. DECODING INTEGER (-129), (LENGTH OF LENGTH = 1) | |
9370 | .*---------------------------------------------------------------------* | |
9371 | :xmp tab=0. | |
9372 | ||
9373 | <TC - DECODING INTEGER (-129), (LENGTH OF LENGTH = 1)> | |
9374 | ||
9375 | <STATIC:ASN> | |
9376 | ||
9377 | TempA | |
9378 | ||
9379 | DEFINITIONS ::= | |
9380 | BEGIN | |
9381 | BERPDU ::= INTEGER | |
9382 | ||
9383 | myIntegerValue BERPDU ::= -129 | |
9384 | ||
9385 | END | |
9386 | ||
9387 | <STATIC> | |
9388 | ||
9389 | import from TempA all; | |
9390 | ||
9391 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9392 | ||
9393 | ||
9394 | <TTCN_TC:EXEC> | |
9395 | ||
9396 | if (dec_BER_PDU('028102FF7F'O) == myIntegerValue) | |
9397 | ||
9398 | ||
9399 | {setverdict(pass);} else {setverdict(fail);} | |
9400 | ||
9401 | ||
9402 | <RESULT> | |
9403 | ||
9404 | Overall verdict: pass | |
9405 | ||
9406 | <END_TC> | |
9407 | ||
9408 | :exmp. | |
9409 | ||
9410 | .*---------------------------------------------------------------------* | |
9411 | :h3. DECODING INTEGER (-129), (LENGTH OF LENGTH = 2) | |
9412 | .*---------------------------------------------------------------------* | |
9413 | :xmp tab=0. | |
9414 | ||
9415 | <TC - DECODING INTEGER (-129), (LENGTH OF LENGTH = 2)> | |
9416 | ||
9417 | <STATIC:ASN> | |
9418 | ||
9419 | TempA | |
9420 | ||
9421 | DEFINITIONS ::= | |
9422 | BEGIN | |
9423 | BERPDU ::= INTEGER | |
9424 | ||
9425 | myIntegerValue BERPDU ::= -129 | |
9426 | ||
9427 | END | |
9428 | ||
9429 | <STATIC> | |
9430 | ||
9431 | import from TempA all; | |
9432 | ||
9433 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9434 | ||
9435 | ||
9436 | <TTCN_TC:EXEC> | |
9437 | ||
9438 | if (dec_BER_PDU('02820002FF7F'O) == myIntegerValue) | |
9439 | ||
9440 | ||
9441 | {setverdict(pass);} else {setverdict(fail);} | |
9442 | ||
9443 | ||
9444 | <RESULT> | |
9445 | ||
9446 | Overall verdict: pass | |
9447 | ||
9448 | <END_TC> | |
9449 | ||
9450 | :exmp. | |
9451 | ||
9452 | .*---------------------------------------------------------------------* | |
9453 | :h3. DECODING [0] EXPLICIT INTEGER (-129), DER | |
9454 | .*---------------------------------------------------------------------* | |
9455 | :xmp tab=0. | |
9456 | ||
9457 | <TC - DECODING [0] EXPLICIT INTEGER (-129), DER> | |
9458 | ||
9459 | <STATIC:ASN> | |
9460 | ||
9461 | TempA | |
9462 | ||
9463 | DEFINITIONS ::= | |
9464 | BEGIN | |
9465 | BERPDU ::= [0] EXPLICIT INTEGER | |
9466 | ||
9467 | myIntegerValue BERPDU ::= -129 | |
9468 | ||
9469 | END | |
9470 | ||
9471 | <STATIC> | |
9472 | ||
9473 | import from TempA all; | |
9474 | ||
9475 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9476 | ||
9477 | ||
9478 | <TTCN_TC:EXEC> | |
9479 | ||
9480 | if (dec_BER_PDU('A0040202FF7F'O) == myIntegerValue) | |
9481 | ||
9482 | ||
9483 | {setverdict(pass);} else {setverdict(fail);} | |
9484 | ||
9485 | ||
9486 | <RESULT> | |
9487 | ||
9488 | Overall verdict: pass | |
9489 | ||
9490 | <END_TC> | |
9491 | ||
9492 | :exmp. | |
9493 | ||
9494 | .*---------------------------------------------------------------------* | |
9495 | :h3. DECODING [0] EXPLICIT INTEGER (-129), CER | |
9496 | .*---------------------------------------------------------------------* | |
9497 | :xmp tab=0. | |
9498 | ||
9499 | <TC - DECODING [0] EXPLICIT INTEGER (-129), CER> | |
9500 | ||
9501 | <STATIC:ASN> | |
9502 | ||
9503 | TempA | |
9504 | ||
9505 | DEFINITIONS ::= | |
9506 | BEGIN | |
9507 | BERPDU ::= [0] EXPLICIT INTEGER | |
9508 | ||
9509 | myIntegerValue BERPDU ::= -129 | |
9510 | ||
9511 | END | |
9512 | ||
9513 | <STATIC> | |
9514 | ||
9515 | import from TempA all; | |
9516 | ||
9517 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9518 | ||
9519 | ||
9520 | <TTCN_TC:EXEC> | |
9521 | ||
9522 | if (dec_BER_PDU('A0800202FF7F0000'O) == myIntegerValue) | |
9523 | ||
9524 | ||
9525 | {setverdict(pass);} else {setverdict(fail);} | |
9526 | ||
9527 | ||
9528 | <RESULT> | |
9529 | ||
9530 | Overall verdict: pass | |
9531 | ||
9532 | <END_TC> | |
9533 | ||
9534 | :exmp. | |
9535 | ||
9536 | .*---------------------------------------------------------------------* | |
9537 | :h3. DECODING [0] EXPLICIT INTEGER (-129), Short form - long form | |
9538 | .*---------------------------------------------------------------------* | |
9539 | :xmp tab=0. | |
9540 | ||
9541 | <TC - DECODING [0] EXPLICIT INTEGER (-129), Short form - long form> | |
9542 | ||
9543 | <STATIC:ASN> | |
9544 | ||
9545 | TempA | |
9546 | ||
9547 | DEFINITIONS ::= | |
9548 | BEGIN | |
9549 | BERPDU ::= [0] EXPLICIT INTEGER | |
9550 | ||
9551 | myIntegerValue BERPDU ::= -129 | |
9552 | ||
9553 | END | |
9554 | ||
9555 | <STATIC> | |
9556 | ||
9557 | import from TempA all; | |
9558 | ||
9559 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9560 | ||
9561 | ||
9562 | <TTCN_TC:EXEC> | |
9563 | ||
9564 | if (dec_BER_PDU('A0040202FF7F'O) == myIntegerValue) | |
9565 | ||
9566 | ||
9567 | {setverdict(pass);} else {setverdict(fail);} | |
9568 | ||
9569 | ||
9570 | <RESULT> | |
9571 | ||
9572 | Overall verdict: pass | |
9573 | ||
9574 | <END_TC> | |
9575 | ||
9576 | :exmp. | |
9577 | ||
9578 | .*---------------------------------------------------------------------* | |
9579 | :h3. DECODING [0] EXPLICIT INTEGER (-129), Long form - short form | |
9580 | .*---------------------------------------------------------------------* | |
9581 | :xmp tab=0. | |
9582 | ||
9583 | <TC - DECODING [0] EXPLICIT INTEGER (-129), Long form - short form> | |
9584 | ||
9585 | <STATIC:ASN> | |
9586 | ||
9587 | TempA | |
9588 | ||
9589 | DEFINITIONS ::= | |
9590 | BEGIN | |
9591 | BERPDU ::= [0] EXPLICIT INTEGER | |
9592 | ||
9593 | myIntegerValue BERPDU ::= -129 | |
9594 | ||
9595 | END | |
9596 | ||
9597 | <STATIC> | |
9598 | ||
9599 | import from TempA all; | |
9600 | ||
9601 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9602 | ||
9603 | ||
9604 | <TTCN_TC:EXEC> | |
9605 | ||
9606 | if (dec_BER_PDU('A081040202FF7F'O) == myIntegerValue) | |
9607 | ||
9608 | ||
9609 | {setverdict(pass);} else {setverdict(fail);} | |
9610 | ||
9611 | ||
9612 | <RESULT> | |
9613 | ||
9614 | Overall verdict: pass | |
9615 | ||
9616 | <END_TC> | |
9617 | ||
9618 | :exmp. | |
9619 | ||
9620 | .*---------------------------------------------------------------------* | |
9621 | :h3. DECODING [0] EXPLICIT INTEGER (-129), Long form Long form | |
9622 | .*---------------------------------------------------------------------* | |
9623 | :xmp tab=0. | |
9624 | ||
9625 | <TC - DECODING [0] EXPLICIT INTEGER (-129), Long form Long form> | |
9626 | ||
9627 | <STATIC:ASN> | |
9628 | ||
9629 | TempA | |
9630 | ||
9631 | DEFINITIONS ::= | |
9632 | BEGIN | |
9633 | BERPDU ::= [0] EXPLICIT INTEGER | |
9634 | ||
9635 | myIntegerValue BERPDU ::= -129 | |
9636 | ||
9637 | END | |
9638 | ||
9639 | <STATIC> | |
9640 | ||
9641 | import from TempA all; | |
9642 | ||
9643 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9644 | ||
9645 | ||
9646 | <TTCN_TC:EXEC> | |
9647 | ||
9648 | if (dec_BER_PDU('A08105028102FF7F'O) == myIntegerValue) | |
9649 | ||
9650 | ||
9651 | {setverdict(pass);} else {setverdict(fail);} | |
9652 | ||
9653 | ||
9654 | <RESULT> | |
9655 | ||
9656 | Overall verdict: pass | |
9657 | ||
9658 | <END_TC> | |
9659 | ||
9660 | :exmp. | |
9661 | ||
9662 | .*---------------------------------------------------------------------* | |
9663 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Short form - Short form, DER | |
9664 | .*---------------------------------------------------------------------* | |
9665 | :xmp tab=0. | |
9666 | ||
9667 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Short form - Short form, DER> | |
9668 | ||
9669 | <STATIC:ASN> | |
9670 | ||
9671 | TempA | |
9672 | ||
9673 | DEFINITIONS ::= | |
9674 | BEGIN | |
9675 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
9676 | ||
9677 | myIntegerValue BERPDU ::= -129 | |
9678 | ||
9679 | END | |
9680 | ||
9681 | <STATIC> | |
9682 | ||
9683 | import from TempA all; | |
9684 | ||
9685 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9686 | ||
9687 | ||
9688 | <TTCN_TC:EXEC> | |
9689 | ||
9690 | if (dec_BER_PDU('E1040202FF7F'O) == myIntegerValue) | |
9691 | ||
9692 | ||
9693 | {setverdict(pass);} else {setverdict(fail);} | |
9694 | ||
9695 | ||
9696 | <RESULT> | |
9697 | ||
9698 | Overall verdict: pass | |
9699 | ||
9700 | <END_TC> | |
9701 | ||
9702 | :exmp. | |
9703 | ||
9704 | .*---------------------------------------------------------------------* | |
9705 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Short form - long form | |
9706 | .*---------------------------------------------------------------------* | |
9707 | :xmp tab=0. | |
9708 | ||
9709 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Short form - long form> | |
9710 | ||
9711 | <STATIC:ASN> | |
9712 | ||
9713 | TempA | |
9714 | ||
9715 | DEFINITIONS ::= | |
9716 | BEGIN | |
9717 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
9718 | ||
9719 | myIntegerValue BERPDU ::= -129 | |
9720 | ||
9721 | END | |
9722 | ||
9723 | <STATIC> | |
9724 | ||
9725 | import from TempA all; | |
9726 | ||
9727 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9728 | ||
9729 | ||
9730 | <TTCN_TC:EXEC> | |
9731 | ||
9732 | if (dec_BER_PDU('E105028102FF7F'O) == myIntegerValue) | |
9733 | ||
9734 | ||
9735 | {setverdict(pass);} else {setverdict(fail);} | |
9736 | ||
9737 | ||
9738 | <RESULT> | |
9739 | ||
9740 | Overall verdict: pass | |
9741 | ||
9742 | <END_TC> | |
9743 | ||
9744 | :exmp. | |
9745 | ||
9746 | .*---------------------------------------------------------------------* | |
9747 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Long form - short form | |
9748 | .*---------------------------------------------------------------------* | |
9749 | :xmp tab=0. | |
9750 | ||
9751 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Long form - short form> | |
9752 | ||
9753 | <STATIC:ASN> | |
9754 | ||
9755 | TempA | |
9756 | ||
9757 | DEFINITIONS ::= | |
9758 | BEGIN | |
9759 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
9760 | ||
9761 | myIntegerValue BERPDU ::= -129 | |
9762 | ||
9763 | END | |
9764 | ||
9765 | <STATIC> | |
9766 | ||
9767 | import from TempA all; | |
9768 | ||
9769 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9770 | ||
9771 | ||
9772 | <TTCN_TC:EXEC> | |
9773 | ||
9774 | if (dec_BER_PDU('E181040202FF7F'O) == myIntegerValue) | |
9775 | ||
9776 | ||
9777 | {setverdict(pass);} else {setverdict(fail);} | |
9778 | ||
9779 | ||
9780 | <RESULT> | |
9781 | ||
9782 | Overall verdict: pass | |
9783 | ||
9784 | <END_TC> | |
9785 | ||
9786 | :exmp. | |
9787 | ||
9788 | .*---------------------------------------------------------------------* | |
9789 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Long form Long form | |
9790 | .*---------------------------------------------------------------------* | |
9791 | :xmp tab=0. | |
9792 | ||
9793 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129), Long form Long form> | |
9794 | ||
9795 | <STATIC:ASN> | |
9796 | ||
9797 | TempA | |
9798 | ||
9799 | DEFINITIONS ::= | |
9800 | BEGIN | |
9801 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
9802 | ||
9803 | myIntegerValue BERPDU ::= -129 | |
9804 | ||
9805 | END | |
9806 | ||
9807 | <STATIC> | |
9808 | ||
9809 | import from TempA all; | |
9810 | ||
9811 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9812 | ||
9813 | ||
9814 | <TTCN_TC:EXEC> | |
9815 | ||
9816 | if (dec_BER_PDU('E18105028102FF7F'O) == myIntegerValue) | |
9817 | ||
9818 | ||
9819 | {setverdict(pass);} else {setverdict(fail);} | |
9820 | ||
9821 | ||
9822 | <RESULT> | |
9823 | ||
9824 | Overall verdict: pass | |
9825 | ||
9826 | <END_TC> | |
9827 | ||
9828 | :exmp. | |
9829 | ||
9830 | .*---------------------------------------------------------------------* | |
9831 | :h3. DECODING [PRIVATE 1] EXPLICIT INTEGER (-129),Indefinite form,CER | |
9832 | .*---------------------------------------------------------------------* | |
9833 | :xmp tab=0. | |
9834 | ||
9835 | <TC - DECODING [PRIVATE 1] EXPLICIT INTEGER (-129),Indefinite form,CER> | |
9836 | ||
9837 | <STATIC:ASN> | |
9838 | ||
9839 | TempA | |
9840 | ||
9841 | DEFINITIONS ::= | |
9842 | BEGIN | |
9843 | BERPDU ::= [PRIVATE 1] EXPLICIT INTEGER | |
9844 | ||
9845 | myIntegerValue BERPDU ::= -129 | |
9846 | ||
9847 | END | |
9848 | ||
9849 | <STATIC> | |
9850 | ||
9851 | import from TempA all; | |
9852 | ||
9853 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9854 | ||
9855 | ||
9856 | <TTCN_TC:EXEC> | |
9857 | ||
9858 | if (dec_BER_PDU('E1800202FF7F0000'O) == myIntegerValue) | |
9859 | ||
9860 | ||
9861 | {setverdict(pass);} else {setverdict(fail);} | |
9862 | ||
9863 | ||
9864 | <RESULT> | |
9865 | ||
9866 | Overall verdict: pass | |
9867 | ||
9868 | <END_TC> | |
9869 | ||
9870 | :exmp. | |
9871 | ||
9872 | .*---------------------------------------------------------------------* | |
9873 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Short form - Short form, DER | |
9874 | .*---------------------------------------------------------------------* | |
9875 | :xmp tab=0. | |
9876 | ||
9877 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Short form - Short form, DER> | |
9878 | ||
9879 | <STATIC:ASN> | |
9880 | ||
9881 | TempA | |
9882 | ||
9883 | DEFINITIONS ::= | |
9884 | BEGIN | |
9885 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
9886 | ||
9887 | myIntegerValue BERPDU ::= -129 | |
9888 | ||
9889 | END | |
9890 | ||
9891 | <STATIC> | |
9892 | ||
9893 | import from TempA all; | |
9894 | ||
9895 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9896 | ||
9897 | ||
9898 | <TTCN_TC:EXEC> | |
9899 | ||
9900 | if (dec_BER_PDU('62040202FF7F'O) == myIntegerValue) | |
9901 | ||
9902 | ||
9903 | {setverdict(pass);} else {setverdict(fail);} | |
9904 | ||
9905 | ||
9906 | <RESULT> | |
9907 | ||
9908 | Overall verdict: pass | |
9909 | ||
9910 | <END_TC> | |
9911 | ||
9912 | :exmp. | |
9913 | ||
9914 | .*---------------------------------------------------------------------* | |
9915 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Short form - long form | |
9916 | .*---------------------------------------------------------------------* | |
9917 | :xmp tab=0. | |
9918 | ||
9919 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Short form - long form> | |
9920 | ||
9921 | <STATIC:ASN> | |
9922 | ||
9923 | TempA | |
9924 | ||
9925 | DEFINITIONS ::= | |
9926 | BEGIN | |
9927 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
9928 | ||
9929 | myIntegerValue BERPDU ::= -129 | |
9930 | ||
9931 | END | |
9932 | ||
9933 | <STATIC> | |
9934 | ||
9935 | import from TempA all; | |
9936 | ||
9937 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9938 | ||
9939 | ||
9940 | <TTCN_TC:EXEC> | |
9941 | ||
9942 | if (dec_BER_PDU('6205028102FF7F'O) == myIntegerValue) | |
9943 | ||
9944 | ||
9945 | {setverdict(pass);} else {setverdict(fail);} | |
9946 | ||
9947 | ||
9948 | <RESULT> | |
9949 | ||
9950 | Overall verdict: pass | |
9951 | ||
9952 | <END_TC> | |
9953 | ||
9954 | :exmp. | |
9955 | ||
9956 | .*---------------------------------------------------------------------* | |
9957 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Long form - short form | |
9958 | .*---------------------------------------------------------------------* | |
9959 | :xmp tab=0. | |
9960 | ||
9961 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Long form - short form> | |
9962 | ||
9963 | <STATIC:ASN> | |
9964 | ||
9965 | TempA | |
9966 | ||
9967 | DEFINITIONS ::= | |
9968 | BEGIN | |
9969 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
9970 | ||
9971 | myIntegerValue BERPDU ::= -129 | |
9972 | ||
9973 | END | |
9974 | ||
9975 | <STATIC> | |
9976 | ||
9977 | import from TempA all; | |
9978 | ||
9979 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
9980 | ||
9981 | ||
9982 | <TTCN_TC:EXEC> | |
9983 | ||
9984 | if (dec_BER_PDU('6281040202FF7F'O) == myIntegerValue) | |
9985 | ||
9986 | ||
9987 | {setverdict(pass);} else {setverdict(fail);} | |
9988 | ||
9989 | ||
9990 | <RESULT> | |
9991 | ||
9992 | Overall verdict: pass | |
9993 | ||
9994 | <END_TC> | |
9995 | ||
9996 | :exmp. | |
9997 | ||
9998 | .*---------------------------------------------------------------------* | |
9999 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Long form Long form | |
10000 | .*---------------------------------------------------------------------* | |
10001 | :xmp tab=0. | |
10002 | ||
10003 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129), Long form Long form> | |
10004 | ||
10005 | <STATIC:ASN> | |
10006 | ||
10007 | TempA | |
10008 | ||
10009 | DEFINITIONS ::= | |
10010 | BEGIN | |
10011 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
10012 | ||
10013 | myIntegerValue BERPDU ::= -129 | |
10014 | ||
10015 | END | |
10016 | ||
10017 | <STATIC> | |
10018 | ||
10019 | import from TempA all; | |
10020 | ||
10021 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10022 | ||
10023 | ||
10024 | <TTCN_TC:EXEC> | |
10025 | ||
10026 | if (dec_BER_PDU('628105028102FF7F'O) == myIntegerValue) | |
10027 | ||
10028 | ||
10029 | {setverdict(pass);} else {setverdict(fail);} | |
10030 | ||
10031 | ||
10032 | <RESULT> | |
10033 | ||
10034 | Overall verdict: pass | |
10035 | ||
10036 | <END_TC> | |
10037 | ||
10038 | :exmp. | |
10039 | ||
10040 | .*---------------------------------------------------------------------* | |
10041 | :h3. DECODING [APPLICATION 2] EXPLICIT INTEGER (-129),Indefinite form,CER | |
10042 | .*---------------------------------------------------------------------* | |
10043 | :xmp tab=0. | |
10044 | ||
10045 | <TC - DECODING [APPLICATION 2] EXPLICIT INTEGER (-129),Indefinite form,CER> | |
10046 | ||
10047 | <STATIC:ASN> | |
10048 | ||
10049 | TempA | |
10050 | ||
10051 | DEFINITIONS ::= | |
10052 | BEGIN | |
10053 | BERPDU ::= [APPLICATION 2] EXPLICIT INTEGER | |
10054 | ||
10055 | myIntegerValue BERPDU ::= -129 | |
10056 | ||
10057 | END | |
10058 | ||
10059 | <STATIC> | |
10060 | ||
10061 | import from TempA all; | |
10062 | ||
10063 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10064 | ||
10065 | ||
10066 | <TTCN_TC:EXEC> | |
10067 | ||
10068 | if (dec_BER_PDU('62800202FF7F0000'O) == myIntegerValue) | |
10069 | ||
10070 | ||
10071 | {setverdict(pass);} else {setverdict(fail);} | |
10072 | ||
10073 | ||
10074 | <RESULT> | |
10075 | ||
10076 | Overall verdict: pass | |
10077 | ||
10078 | <END_TC> | |
10079 | ||
10080 | :exmp. | |
10081 | ||
10082 | .*---------------------------------------------------------------------* | |
10083 | :h3. DECODING [0] IMPLICIT INTEGER (-129),Short form CER,DER | |
10084 | .*---------------------------------------------------------------------* | |
10085 | :xmp tab=0. | |
10086 | ||
10087 | <TC - DECODING [0] IMPLICIT INTEGER (-129),Short form CER,DER> | |
10088 | ||
10089 | <STATIC:ASN> | |
10090 | ||
10091 | TempA | |
10092 | ||
10093 | DEFINITIONS ::= | |
10094 | BEGIN | |
10095 | BERPDU ::= [0] IMPLICIT INTEGER | |
10096 | ||
10097 | myIntegerValue BERPDU ::= -129 | |
10098 | ||
10099 | END | |
10100 | ||
10101 | <STATIC> | |
10102 | ||
10103 | import from TempA all; | |
10104 | ||
10105 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10106 | ||
10107 | ||
10108 | <TTCN_TC:EXEC> | |
10109 | ||
10110 | if (dec_BER_PDU('8002FF7F'O) == myIntegerValue) | |
10111 | ||
10112 | ||
10113 | {setverdict(pass);} else {setverdict(fail);} | |
10114 | ||
10115 | ||
10116 | <RESULT> | |
10117 | ||
10118 | Overall verdict: pass | |
10119 | ||
10120 | <END_TC> | |
10121 | ||
10122 | :exmp. | |
10123 | ||
10124 | .*---------------------------------------------------------------------* | |
10125 | :h3. DECODING [0] IMPLICIT INTEGER (-129),Long form | |
10126 | .*---------------------------------------------------------------------* | |
10127 | :xmp tab=0. | |
10128 | ||
10129 | <TC - DECODING [0] IMPLICIT INTEGER (-129),Long form> | |
10130 | ||
10131 | <STATIC:ASN> | |
10132 | ||
10133 | TempA | |
10134 | ||
10135 | DEFINITIONS ::= | |
10136 | BEGIN | |
10137 | BERPDU ::= [0] IMPLICIT INTEGER | |
10138 | ||
10139 | myIntegerValue BERPDU ::= -129 | |
10140 | ||
10141 | END | |
10142 | ||
10143 | <STATIC> | |
10144 | ||
10145 | import from TempA all; | |
10146 | ||
10147 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10148 | ||
10149 | ||
10150 | <TTCN_TC:EXEC> | |
10151 | ||
10152 | if (dec_BER_PDU('808102FF7F'O) == myIntegerValue) | |
10153 | ||
10154 | ||
10155 | {setverdict(pass);} else {setverdict(fail);} | |
10156 | ||
10157 | ||
10158 | <RESULT> | |
10159 | ||
10160 | Overall verdict: pass | |
10161 | ||
10162 | <END_TC> | |
10163 | ||
10164 | :exmp. | |
10165 | ||
10166 | .*---------------------------------------------------------------------* | |
10167 | :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-129),Short form CER,DER | |
10168 | .*---------------------------------------------------------------------* | |
10169 | :xmp tab=0. | |
10170 | ||
10171 | <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-129),Short form CER,DER> | |
10172 | ||
10173 | <STATIC:ASN> | |
10174 | ||
10175 | TempA | |
10176 | ||
10177 | DEFINITIONS ::= | |
10178 | BEGIN | |
10179 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
10180 | ||
10181 | myIntegerValue BERPDU ::= -129 | |
10182 | ||
10183 | END | |
10184 | ||
10185 | <STATIC> | |
10186 | ||
10187 | import from TempA all; | |
10188 | ||
10189 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10190 | ||
10191 | ||
10192 | <TTCN_TC:EXEC> | |
10193 | ||
10194 | if (dec_BER_PDU('C102FF7F'O) == myIntegerValue) | |
10195 | ||
10196 | ||
10197 | {setverdict(pass);} else {setverdict(fail);} | |
10198 | ||
10199 | ||
10200 | <RESULT> | |
10201 | ||
10202 | Overall verdict: pass | |
10203 | ||
10204 | <END_TC> | |
10205 | ||
10206 | :exmp. | |
10207 | ||
10208 | .*---------------------------------------------------------------------* | |
10209 | :h3. DECODING [PRIVATE 1] IMPLICIT INTEGER (-129),Long form | |
10210 | .*---------------------------------------------------------------------* | |
10211 | :xmp tab=0. | |
10212 | ||
10213 | <TC - DECODING [PRIVATE 1] IMPLICIT INTEGER (-129),Long form> | |
10214 | ||
10215 | <STATIC:ASN> | |
10216 | ||
10217 | TempA | |
10218 | ||
10219 | DEFINITIONS ::= | |
10220 | BEGIN | |
10221 | BERPDU ::= [PRIVATE 1] IMPLICIT INTEGER | |
10222 | ||
10223 | myIntegerValue BERPDU ::= -129 | |
10224 | ||
10225 | END | |
10226 | ||
10227 | <STATIC> | |
10228 | ||
10229 | import from TempA all; | |
10230 | ||
10231 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10232 | ||
10233 | ||
10234 | <TTCN_TC:EXEC> | |
10235 | ||
10236 | if (dec_BER_PDU('C18102FF7F'O) == myIntegerValue) | |
10237 | ||
10238 | ||
10239 | {setverdict(pass);} else {setverdict(fail);} | |
10240 | ||
10241 | ||
10242 | <RESULT> | |
10243 | ||
10244 | Overall verdict: pass | |
10245 | ||
10246 | <END_TC> | |
10247 | ||
10248 | :exmp. | |
10249 | ||
10250 | .*---------------------------------------------------------------------* | |
10251 | :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-129),Short form CER,DER | |
10252 | .*---------------------------------------------------------------------* | |
10253 | :xmp tab=0. | |
10254 | ||
10255 | <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-129),Short form CER,DER> | |
10256 | ||
10257 | <STATIC:ASN> | |
10258 | ||
10259 | TempA | |
10260 | ||
10261 | DEFINITIONS ::= | |
10262 | BEGIN | |
10263 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
10264 | ||
10265 | myIntegerValue BERPDU ::= -129 | |
10266 | ||
10267 | END | |
10268 | ||
10269 | <STATIC> | |
10270 | ||
10271 | import from TempA all; | |
10272 | ||
10273 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10274 | ||
10275 | ||
10276 | <TTCN_TC:EXEC> | |
10277 | ||
10278 | if (dec_BER_PDU('4202FF7F'O) == myIntegerValue) | |
10279 | ||
10280 | ||
10281 | {setverdict(pass);} else {setverdict(fail);} | |
10282 | ||
10283 | ||
10284 | <RESULT> | |
10285 | ||
10286 | Overall verdict: pass | |
10287 | ||
10288 | <END_TC> | |
10289 | ||
10290 | :exmp. | |
10291 | ||
10292 | .*---------------------------------------------------------------------* | |
10293 | :h3. DECODING [APPLICATION 2] IMPLICIT INTEGER (-129),Long form | |
10294 | .*---------------------------------------------------------------------* | |
10295 | :xmp tab=0. | |
10296 | ||
10297 | <TC - DECODING [APPLICATION 2] IMPLICIT INTEGER (-129),Long form> | |
10298 | ||
10299 | <STATIC:ASN> | |
10300 | ||
10301 | TempA | |
10302 | ||
10303 | DEFINITIONS ::= | |
10304 | BEGIN | |
10305 | BERPDU ::= [APPLICATION 2] IMPLICIT INTEGER | |
10306 | ||
10307 | myIntegerValue BERPDU ::= -129 | |
10308 | ||
10309 | END | |
10310 | ||
10311 | <STATIC> | |
10312 | ||
10313 | import from TempA all; | |
10314 | ||
10315 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10316 | ||
10317 | ||
10318 | <TTCN_TC:EXEC> | |
10319 | ||
10320 | if (dec_BER_PDU('428102FF7F'O) == myIntegerValue) | |
10321 | ||
10322 | ||
10323 | {setverdict(pass);} else {setverdict(fail);} | |
10324 | ||
10325 | ||
10326 | <RESULT> | |
10327 | ||
10328 | Overall verdict: pass | |
10329 | ||
10330 | <END_TC> | |
10331 | ||
10332 | :exmp. | |
10333 | ||
10334 | .*---------------------------------------------------------------------* | |
10335 | :h3. DECODING DER integer (5) with Context Specific TAG = 30 | |
10336 | .*---------------------------------------------------------------------* | |
10337 | :xmp tab=0. | |
10338 | ||
10339 | <TC - DECODING DER integer (5) with Context Specific TAG = 30> | |
10340 | ||
10341 | <STATIC:ASN> | |
10342 | ||
10343 | TempA | |
10344 | ||
10345 | DEFINITIONS ::= | |
10346 | BEGIN | |
10347 | BERPDU ::= [30] EXPLICIT INTEGER | |
10348 | ||
10349 | myIntegerValue BERPDU ::= 5 | |
10350 | ||
10351 | END | |
10352 | ||
10353 | <STATIC> | |
10354 | ||
10355 | import from TempA all; | |
10356 | ||
10357 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10358 | ||
10359 | ||
10360 | <TTCN_TC:EXEC> | |
10361 | ||
10362 | if (dec_BER_PDU('BE03020105'O) == myIntegerValue) | |
10363 | ||
10364 | ||
10365 | {setverdict(pass);} else {setverdict(fail);} | |
10366 | ||
10367 | ||
10368 | <RESULT> | |
10369 | ||
10370 | Overall verdict: pass | |
10371 | ||
10372 | <END_TC> | |
10373 | ||
10374 | :exmp. | |
10375 | ||
10376 | .*---------------------------------------------------------------------* | |
10377 | :h3. DECODING CER integer (5) with Context Specific TAG = 30 | |
10378 | .*---------------------------------------------------------------------* | |
10379 | :xmp tab=0. | |
10380 | ||
10381 | <TC - DECODING CER integer (5) with Context Specific TAG = 30> | |
10382 | ||
10383 | <STATIC:ASN> | |
10384 | ||
10385 | TempA | |
10386 | ||
10387 | DEFINITIONS ::= | |
10388 | BEGIN | |
10389 | BERPDU ::= [30] EXPLICIT INTEGER | |
10390 | ||
10391 | myIntegerValue BERPDU ::= 5 | |
10392 | ||
10393 | END | |
10394 | ||
10395 | <STATIC> | |
10396 | ||
10397 | import from TempA all; | |
10398 | ||
10399 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10400 | ||
10401 | ||
10402 | <TTCN_TC:EXEC> | |
10403 | ||
10404 | if (dec_BER_PDU('BE800201050000'O) == myIntegerValue) | |
10405 | ||
10406 | ||
10407 | {setverdict(pass);} else {setverdict(fail);} | |
10408 | ||
10409 | ||
10410 | <RESULT> | |
10411 | ||
10412 | Overall verdict: pass | |
10413 | ||
10414 | <END_TC> | |
10415 | ||
10416 | :exmp. | |
10417 | ||
10418 | .*---------------------------------------------------------------------* | |
10419 | :h3. DECODING DER integer (5) with Context Specific TAG = 31 | |
10420 | .*---------------------------------------------------------------------* | |
10421 | :xmp tab=0. | |
10422 | ||
10423 | <TC - DECODING DER integer (5) with Context Specific TAG = 31> | |
10424 | ||
10425 | <STATIC:ASN> | |
10426 | ||
10427 | TempA | |
10428 | ||
10429 | DEFINITIONS ::= | |
10430 | BEGIN | |
10431 | BERPDU ::= [31] EXPLICIT INTEGER | |
10432 | ||
10433 | myIntegerValue BERPDU ::= 5 | |
10434 | ||
10435 | END | |
10436 | ||
10437 | <STATIC> | |
10438 | ||
10439 | import from TempA all; | |
10440 | ||
10441 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10442 | ||
10443 | ||
10444 | <TTCN_TC:EXEC> | |
10445 | ||
10446 | if (dec_BER_PDU('BF1F03020105'O) == myIntegerValue) | |
10447 | ||
10448 | ||
10449 | {setverdict(pass);} else {setverdict(fail);} | |
10450 | ||
10451 | ||
10452 | <RESULT> | |
10453 | ||
10454 | Overall verdict: pass | |
10455 | ||
10456 | <END_TC> | |
10457 | ||
10458 | :exmp. | |
10459 | ||
10460 | .*---------------------------------------------------------------------* | |
10461 | :h3. DECODING CER integer (5) with Context Specific TAG = 31 | |
10462 | .*---------------------------------------------------------------------* | |
10463 | :xmp tab=0. | |
10464 | ||
10465 | <TC - DECODING CER integer (5) with Context Specific TAG = 31> | |
10466 | ||
10467 | <STATIC:ASN> | |
10468 | ||
10469 | TempA | |
10470 | ||
10471 | DEFINITIONS ::= | |
10472 | BEGIN | |
10473 | BERPDU ::= [31] EXPLICIT INTEGER | |
10474 | ||
10475 | myIntegerValue BERPDU ::= 5 | |
10476 | ||
10477 | END | |
10478 | ||
10479 | <STATIC> | |
10480 | ||
10481 | import from TempA all; | |
10482 | ||
10483 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10484 | ||
10485 | ||
10486 | <TTCN_TC:EXEC> | |
10487 | ||
10488 | if (dec_BER_PDU('BF1F800201050000'O) == myIntegerValue) | |
10489 | ||
10490 | ||
10491 | {setverdict(pass);} else {setverdict(fail);} | |
10492 | ||
10493 | ||
10494 | <RESULT> | |
10495 | ||
10496 | Overall verdict: pass | |
10497 | ||
10498 | <END_TC> | |
10499 | ||
10500 | :exmp. | |
10501 | ||
10502 | .*---------------------------------------------------------------------* | |
10503 | :h3. DECODING DER integer (5) with Context Specific TAG = 127 | |
10504 | .*---------------------------------------------------------------------* | |
10505 | :xmp tab=0. | |
10506 | ||
10507 | <TC - DECODING DER integer (5) with Context Specific TAG = 127> | |
10508 | ||
10509 | <STATIC:ASN> | |
10510 | ||
10511 | TempA | |
10512 | ||
10513 | DEFINITIONS ::= | |
10514 | BEGIN | |
10515 | BERPDU ::= [127] EXPLICIT INTEGER | |
10516 | ||
10517 | myIntegerValue BERPDU ::= 5 | |
10518 | ||
10519 | END | |
10520 | ||
10521 | <STATIC> | |
10522 | ||
10523 | import from TempA all; | |
10524 | ||
10525 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10526 | ||
10527 | ||
10528 | <TTCN_TC:EXEC> | |
10529 | ||
10530 | if (dec_BER_PDU('BF7F03020105'O) == myIntegerValue) | |
10531 | ||
10532 | ||
10533 | {setverdict(pass);} else {setverdict(fail);} | |
10534 | ||
10535 | ||
10536 | <RESULT> | |
10537 | ||
10538 | Overall verdict: pass | |
10539 | ||
10540 | <END_TC> | |
10541 | ||
10542 | :exmp. | |
10543 | ||
10544 | .*---------------------------------------------------------------------* | |
10545 | :h3. DECODING CER integer (5) with Context Specific TAG = 127 | |
10546 | .*---------------------------------------------------------------------* | |
10547 | :xmp tab=0. | |
10548 | ||
10549 | <TC - DECODING CER integer (5) with Context Specific TAG = 127> | |
10550 | ||
10551 | <STATIC:ASN> | |
10552 | ||
10553 | TempA | |
10554 | ||
10555 | DEFINITIONS ::= | |
10556 | BEGIN | |
10557 | BERPDU ::= [127] EXPLICIT INTEGER | |
10558 | ||
10559 | myIntegerValue BERPDU ::= 5 | |
10560 | ||
10561 | END | |
10562 | ||
10563 | <STATIC> | |
10564 | ||
10565 | import from TempA all; | |
10566 | ||
10567 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10568 | ||
10569 | ||
10570 | <TTCN_TC:EXEC> | |
10571 | ||
10572 | if (dec_BER_PDU('BF7F800201050000'O) == myIntegerValue) | |
10573 | ||
10574 | ||
10575 | {setverdict(pass);} else {setverdict(fail);} | |
10576 | ||
10577 | ||
10578 | <RESULT> | |
10579 | ||
10580 | Overall verdict: pass | |
10581 | ||
10582 | <END_TC> | |
10583 | ||
10584 | :exmp. | |
10585 | ||
10586 | .*---------------------------------------------------------------------* | |
10587 | :h3. DECODING DER integer (5) with Context Specific TAG = 128 | |
10588 | .*---------------------------------------------------------------------* | |
10589 | :xmp tab=0. | |
10590 | ||
10591 | <TC - DECODING DER integer (5) with Context Specific TAG = 128> | |
10592 | ||
10593 | <STATIC:ASN> | |
10594 | ||
10595 | TempA | |
10596 | ||
10597 | DEFINITIONS ::= | |
10598 | BEGIN | |
10599 | BERPDU ::= [128] EXPLICIT INTEGER | |
10600 | ||
10601 | myIntegerValue BERPDU ::= 5 | |
10602 | ||
10603 | END | |
10604 | ||
10605 | <STATIC> | |
10606 | ||
10607 | import from TempA all; | |
10608 | ||
10609 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10610 | ||
10611 | ||
10612 | <TTCN_TC:EXEC> | |
10613 | ||
10614 | if (dec_BER_PDU('BF810003020105'O) == myIntegerValue) | |
10615 | ||
10616 | ||
10617 | {setverdict(pass);} else {setverdict(fail);} | |
10618 | ||
10619 | ||
10620 | <RESULT> | |
10621 | ||
10622 | Overall verdict: pass | |
10623 | ||
10624 | <END_TC> | |
10625 | ||
10626 | :exmp. | |
10627 | ||
10628 | .*---------------------------------------------------------------------* | |
10629 | :h3. DECODING CER integer (5) with Context Specific TAG = 128 | |
10630 | .*---------------------------------------------------------------------* | |
10631 | :xmp tab=0. | |
10632 | ||
10633 | <TC - DECODING CER integer (5) with Context Specific TAG = 128> | |
10634 | ||
10635 | <STATIC:ASN> | |
10636 | ||
10637 | TempA | |
10638 | ||
10639 | DEFINITIONS ::= | |
10640 | BEGIN | |
10641 | BERPDU ::= [128] EXPLICIT INTEGER | |
10642 | ||
10643 | myIntegerValue BERPDU ::= 5 | |
10644 | ||
10645 | END | |
10646 | ||
10647 | <STATIC> | |
10648 | ||
10649 | import from TempA all; | |
10650 | ||
10651 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10652 | ||
10653 | ||
10654 | <TTCN_TC:EXEC> | |
10655 | ||
10656 | if (dec_BER_PDU('BF8100800201050000'O) == myIntegerValue) | |
10657 | ||
10658 | ||
10659 | {setverdict(pass);} else {setverdict(fail);} | |
10660 | ||
10661 | ||
10662 | <RESULT> | |
10663 | ||
10664 | Overall verdict: pass | |
10665 | ||
10666 | <END_TC> | |
10667 | ||
10668 | :exmp. | |
10669 | ||
10670 | .*---------------------------------------------------------------------* | |
10671 | :h3. DECODING DER integer (5) with Context Specific TAG = 16383 | |
10672 | .*---------------------------------------------------------------------* | |
10673 | :xmp tab=0. | |
10674 | ||
10675 | <TC - DECODING DER integer (5) with Context Specific TAG = 16383> | |
10676 | ||
10677 | <STATIC:ASN> | |
10678 | ||
10679 | TempA | |
10680 | ||
10681 | DEFINITIONS ::= | |
10682 | BEGIN | |
10683 | BERPDU ::= [16383] EXPLICIT INTEGER | |
10684 | ||
10685 | myIntegerValue BERPDU ::= 5 | |
10686 | ||
10687 | END | |
10688 | ||
10689 | <STATIC> | |
10690 | ||
10691 | import from TempA all; | |
10692 | ||
10693 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10694 | ||
10695 | ||
10696 | <TTCN_TC:EXEC> | |
10697 | ||
10698 | if (dec_BER_PDU('BFFF7F03020105'O) == myIntegerValue) | |
10699 | ||
10700 | ||
10701 | {setverdict(pass);} else {setverdict(fail);} | |
10702 | ||
10703 | ||
10704 | <RESULT> | |
10705 | ||
10706 | Overall verdict: pass | |
10707 | ||
10708 | <END_TC> | |
10709 | ||
10710 | :exmp. | |
10711 | ||
10712 | .*---------------------------------------------------------------------* | |
10713 | :h3. DECODING CER integer (5) with Context Specific TAG = 16383 | |
10714 | .*---------------------------------------------------------------------* | |
10715 | :xmp tab=0. | |
10716 | ||
10717 | <TC - DECODING CER integer (5) with Context Specific TAG = 16383> | |
10718 | ||
10719 | <STATIC:ASN> | |
10720 | ||
10721 | TempA | |
10722 | ||
10723 | DEFINITIONS ::= | |
10724 | BEGIN | |
10725 | BERPDU ::= [16383] EXPLICIT INTEGER | |
10726 | ||
10727 | myIntegerValue BERPDU ::= 5 | |
10728 | ||
10729 | END | |
10730 | ||
10731 | <STATIC> | |
10732 | ||
10733 | import from TempA all; | |
10734 | ||
10735 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10736 | ||
10737 | ||
10738 | <TTCN_TC:EXEC> | |
10739 | ||
10740 | if (dec_BER_PDU('BFFF7F800201050000'O) == myIntegerValue) | |
10741 | ||
10742 | ||
10743 | {setverdict(pass);} else {setverdict(fail);} | |
10744 | ||
10745 | ||
10746 | <RESULT> | |
10747 | ||
10748 | Overall verdict: pass | |
10749 | ||
10750 | <END_TC> | |
10751 | ||
10752 | :exmp. | |
10753 | ||
10754 | .*---------------------------------------------------------------------* | |
10755 | :h3. DECODING DER integer (5) with Context Specific TAG = 16384 | |
10756 | .*---------------------------------------------------------------------* | |
10757 | :xmp tab=0. | |
10758 | ||
10759 | <TC - DECODING DER integer (5) with Context Specific TAG = 16384> | |
10760 | ||
10761 | <STATIC:ASN> | |
10762 | ||
10763 | TempA | |
10764 | ||
10765 | DEFINITIONS ::= | |
10766 | BEGIN | |
10767 | BERPDU ::= [16384] EXPLICIT INTEGER | |
10768 | ||
10769 | myIntegerValue BERPDU ::= 5 | |
10770 | ||
10771 | END | |
10772 | ||
10773 | <STATIC> | |
10774 | ||
10775 | import from TempA all; | |
10776 | ||
10777 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10778 | ||
10779 | ||
10780 | <TTCN_TC:EXEC> | |
10781 | ||
10782 | if (dec_BER_PDU('BF81800003020105'O) == myIntegerValue) | |
10783 | ||
10784 | ||
10785 | {setverdict(pass);} else {setverdict(fail);} | |
10786 | ||
10787 | ||
10788 | <RESULT> | |
10789 | ||
10790 | Overall verdict: pass | |
10791 | ||
10792 | <END_TC> | |
10793 | ||
10794 | :exmp. | |
10795 | ||
10796 | .*---------------------------------------------------------------------* | |
10797 | :h3. DECODING CER integer (5) with Context Specific TAG = 16384 | |
10798 | .*---------------------------------------------------------------------* | |
10799 | :xmp tab=0. | |
10800 | ||
10801 | <TC - DECODING CER integer (5) with Context Specific TAG = 16384> | |
10802 | ||
10803 | <STATIC:ASN> | |
10804 | ||
10805 | TempA | |
10806 | ||
10807 | DEFINITIONS ::= | |
10808 | BEGIN | |
10809 | BERPDU ::= [16384] EXPLICIT INTEGER | |
10810 | ||
10811 | myIntegerValue BERPDU ::= 5 | |
10812 | ||
10813 | END | |
10814 | ||
10815 | <STATIC> | |
10816 | ||
10817 | import from TempA all; | |
10818 | ||
10819 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
10820 | ||
10821 | ||
10822 | <TTCN_TC:EXEC> | |
10823 | ||
10824 | if (dec_BER_PDU('BF818000800201050000'O) == myIntegerValue) | |
10825 | ||
10826 | ||
10827 | {setverdict(pass);} else {setverdict(fail);} | |
10828 | ||
10829 | ||
10830 | <RESULT> | |
10831 | ||
10832 | Overall verdict: pass | |
10833 | ||
10834 | <END_TC> | |
10835 | ||
10836 | :exmp. | |
10837 | ||
10838 | .*---------------------------------------------------------------------* | |
10839 | :h3. DER + CER encoding of ENUMERATED third(-9) hardcoded positive | |
10840 | .*---------------------------------------------------------------------* | |
10841 | :xmp tab=0. | |
10842 | ||
10843 | <TC - DER + CER encoding of ENUMERATED third(-9) hardcoded positive > | |
10844 | ||
10845 | <STATIC:ASN> | |
10846 | ||
10847 | TempA | |
10848 | ||
10849 | DEFINITIONS ::= | |
10850 | BEGIN | |
10851 | BERPDU ::= ENUMERATED {first(-5), second(0), third(9)} | |
10852 | END | |
10853 | ||
10854 | <STATIC> | |
10855 | ||
10856 | import from TempA all; | |
10857 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
10858 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
10859 | ||
10860 | const BERPDU b := third | |
10861 | ||
10862 | <TTCN_TC:EXEC> | |
10863 | ||
10864 | if ((enc_DER_PDU(b) == '0A0109'O)and(enc_CER_PDU(b) == '0A0109'O)) {setverdict(pass);} else {setverdict(fail);} | |
10865 | ||
10866 | <RESULT> | |
10867 | ||
10868 | Overall verdict: pass | |
10869 | ||
10870 | <END_TC> | |
10871 | ||
10872 | :exmp. | |
10873 | ||
10874 | .*---------------------------------------------------------------------* | |
10875 | :h3. DER + CER encoding of ENUMERATED first(0) hardcoded negative | |
10876 | .*---------------------------------------------------------------------* | |
10877 | :xmp tab=0. | |
10878 | ||
10879 | <TC - DER + CER encoding of ENUMERATED first(0) hardcoded negative> | |
10880 | ||
10881 | <STATIC:ASN> | |
10882 | ||
10883 | TempA | |
10884 | ||
10885 | DEFINITIONS ::= | |
10886 | BEGIN | |
10887 | BERPDU ::= ENUMERATED {first(-5), second(0), third(9)} | |
10888 | END | |
10889 | ||
10890 | <STATIC> | |
10891 | ||
10892 | import from TempA all; | |
10893 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
10894 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
10895 | ||
10896 | const BERPDU b := first | |
10897 | ||
10898 | <TTCN_TC:EXEC> | |
10899 | ||
10900 | if ((enc_DER_PDU(b) == '0A01FB'O)and(enc_CER_PDU(b) == '0A01FB'O)) {setverdict(pass);} else {setverdict(fail);} | |
10901 | ||
10902 | <RESULT> | |
10903 | ||
10904 | Overall verdict: pass | |
10905 | ||
10906 | <END_TC> | |
10907 | ||
10908 | :exmp. | |
10909 | ||
10910 | .*---------------------------------------------------------------------* | |
10911 | :h3. DER + CER encoding of ENUMERATED second(0) hardcoded zero | |
10912 | .*---------------------------------------------------------------------* | |
10913 | :xmp tab=0. | |
10914 | ||
10915 | <TC - DER + CER encoding of ENUMERATED second(0) hardcoded zero> | |
10916 | ||
10917 | <STATIC:ASN> | |
10918 | ||
10919 | TempA | |
10920 | ||
10921 | DEFINITIONS ::= | |
10922 | BEGIN | |
10923 | BERPDU ::= ENUMERATED {first(-5), second(0), third(9)} | |
10924 | END | |
10925 | ||
10926 | <STATIC> | |
10927 | ||
10928 | import from TempA all; | |
10929 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
10930 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
10931 | ||
10932 | const BERPDU b := second | |
10933 | ||
10934 | <TTCN_TC:EXEC> | |
10935 | ||
10936 | if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);} | |
10937 | ||
10938 | <RESULT> | |
10939 | ||
10940 | Overall verdict: pass | |
10941 | ||
10942 | <END_TC> | |
10943 | ||
10944 | :exmp. | |
10945 | ||
10946 | .*---------------------------------------------------------------------* | |
10947 | :h3. DER + CER encoding of ENUMERATED third, no hardcoding | |
10948 | .*---------------------------------------------------------------------* | |
10949 | :xmp tab=0. | |
10950 | ||
10951 | <TC - DER + CER encoding of ENUMERATED third, no hardcoding> | |
10952 | ||
10953 | <STATIC:ASN> | |
10954 | ||
10955 | TempA | |
10956 | ||
10957 | DEFINITIONS ::= | |
10958 | BEGIN | |
10959 | BERPDU ::= ENUMERATED {first, second, third} | |
10960 | END | |
10961 | ||
10962 | <STATIC> | |
10963 | ||
10964 | import from TempA all; | |
10965 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
10966 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
10967 | ||
10968 | const BERPDU b := third | |
10969 | ||
10970 | <TTCN_TC:EXEC> | |
10971 | ||
10972 | if ((enc_DER_PDU(b) == '0A0102'O)and(enc_CER_PDU(b) == '0A0102'O)) {setverdict(pass);} else {setverdict(fail);} | |
10973 | ||
10974 | <RESULT> | |
10975 | ||
10976 | Overall verdict: pass | |
10977 | ||
10978 | <END_TC> | |
10979 | ||
10980 | :exmp. | |
10981 | ||
10982 | .*---------------------------------------------------------------------* | |
10983 | :h3. DER + CER encoding of ENUMERATED first, no hardcoding | |
10984 | .*---------------------------------------------------------------------* | |
10985 | :xmp tab=0. | |
10986 | ||
10987 | <TC - DER + CER encoding of ENUMERATED first, no hardcoding> | |
10988 | ||
10989 | <STATIC:ASN> | |
10990 | ||
10991 | TempA | |
10992 | ||
10993 | DEFINITIONS ::= | |
10994 | BEGIN | |
10995 | BERPDU ::= ENUMERATED {first, second, third} | |
10996 | END | |
10997 | ||
10998 | <STATIC> | |
10999 | ||
11000 | import from TempA all; | |
11001 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
11002 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
11003 | ||
11004 | const BERPDU b := first | |
11005 | ||
11006 | <TTCN_TC:EXEC> | |
11007 | ||
11008 | if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);} | |
11009 | ||
11010 | <RESULT> | |
11011 | ||
11012 | Overall verdict: pass | |
11013 | ||
11014 | <END_TC> | |
11015 | ||
11016 | :exmp. | |
11017 | ||
11018 | .*---------------------------------------------------------------------* | |
11019 | :h3. DER + CER encoding of ENUMERATED second, no hardcoding | |
11020 | .*---------------------------------------------------------------------* | |
11021 | :xmp tab=0. | |
11022 | ||
11023 | <TC - DER + CER encoding of ENUMERATED second, no hardcoding> | |
11024 | ||
11025 | <STATIC:ASN> | |
11026 | ||
11027 | TempA | |
11028 | ||
11029 | DEFINITIONS ::= | |
11030 | BEGIN | |
11031 | BERPDU ::= ENUMERATED {first(-5), second(0), third(9)} | |
11032 | END | |
11033 | ||
11034 | <STATIC> | |
11035 | ||
11036 | import from TempA all; | |
11037 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
11038 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
11039 | ||
11040 | const BERPDU b := second | |
11041 | ||
11042 | <TTCN_TC:EXEC> | |
11043 | ||
11044 | if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);} | |
11045 | ||
11046 | <RESULT> | |
11047 | ||
11048 | Overall verdict: pass | |
11049 | ||
11050 | <END_TC> | |
11051 | ||
11052 | :exmp. | |
11053 | ||
11054 | .*---------------------------------------------------------------------* | |
11055 | :h3. DER + CER encoding of ENUMERATED first | |
11056 | .*---------------------------------------------------------------------* | |
11057 | :xmp tab=0. | |
11058 | ||
11059 | <TC - DER + CER encoding of ENUMERATED first> | |
11060 | ||
11061 | <STATIC:ASN> | |
11062 | ||
11063 | TempA | |
11064 | ||
11065 | DEFINITIONS ::= | |
11066 | BEGIN | |
11067 | BERPDU ::= ENUMERATED {first, second(0),third} | |
11068 | END | |
11069 | ||
11070 | <STATIC> | |
11071 | ||
11072 | import from TempA all; | |
11073 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
11074 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
11075 | ||
11076 | const BERPDU b := first | |
11077 | ||
11078 | <TTCN_TC:EXEC> | |
11079 | ||
11080 | if ((enc_DER_PDU(b) == '0A0101'O)and(enc_CER_PDU(b) == '0A0101'O)) {setverdict(pass);} else {setverdict(fail);} | |
11081 | ||
11082 | <RESULT> | |
11083 | ||
11084 | Overall verdict: pass | |
11085 | ||
11086 | <END_TC> | |
11087 | ||
11088 | :exmp. | |
11089 | ||
11090 | .*---------------------------------------------------------------------* | |
11091 | :h3. DER + CER encoding of ENUMERATED second(0) | |
11092 | .*---------------------------------------------------------------------* | |
11093 | :xmp tab=0. | |
11094 | ||
11095 | <TC - DER + CER encoding of ENUMERATED second(0)> | |
11096 | ||
11097 | <STATIC:ASN> | |
11098 | ||
11099 | TempA | |
11100 | ||
11101 | DEFINITIONS ::= | |
11102 | BEGIN | |
11103 | BERPDU ::= ENUMERATED {first, second(0),third} | |
11104 | END | |
11105 | ||
11106 | <STATIC> | |
11107 | ||
11108 | import from TempA all; | |
11109 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
11110 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
11111 | ||
11112 | const BERPDU b := second | |
11113 | ||
11114 | <TTCN_TC:EXEC> | |
11115 | ||
11116 | if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);} | |
11117 | ||
11118 | <RESULT> | |
11119 | ||
11120 | Overall verdict: pass | |
11121 | ||
11122 | <END_TC> | |
11123 | ||
11124 | :exmp. | |
11125 | ||
11126 | .*---------------------------------------------------------------------* | |
11127 | :h3. DER + CER encoding of ENUMERATED third | |
11128 | .*---------------------------------------------------------------------* | |
11129 | :xmp tab=0. | |
11130 | ||
11131 | <TC - DER + CER encoding of ENUMERATED third> | |
11132 | ||
11133 | <STATIC:ASN> | |
11134 | ||
11135 | TempA | |
11136 | ||
11137 | DEFINITIONS ::= | |
11138 | BEGIN | |
11139 | BERPDU ::= ENUMERATED {first, second(0),third} | |
11140 | END | |
11141 | ||
11142 | <STATIC> | |
11143 | ||
11144 | import from TempA all; | |
11145 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
11146 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
11147 | ||
11148 | const BERPDU b := third | |
11149 | ||
11150 | <TTCN_TC:EXEC> | |
11151 | ||
11152 | if ((enc_DER_PDU(b) == '0A0102'O)and(enc_CER_PDU(b) == '0A0102'O)) {setverdict(pass);} else {setverdict(fail);} | |
11153 | ||
11154 | <RESULT> | |
11155 | ||
11156 | Overall verdict: pass | |
11157 | ||
11158 | <END_TC> | |
11159 | ||
11160 | :exmp. | |
11161 | ||
11162 | .*---------------------------------------------------------------------* | |
11163 | :h3. DER + CER encoding of ENUMERATED first | |
11164 | .*---------------------------------------------------------------------* | |
11165 | :xmp tab=0. | |
11166 | ||
11167 | <TC - DER + CER encoding of ENUMERATED first> | |
11168 | ||
11169 | <STATIC:ASN> | |
11170 | ||
11171 | TempA | |
11172 | ||
11173 | DEFINITIONS ::= | |
11174 | BEGIN | |
11175 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11176 | END | |
11177 | ||
11178 | <STATIC> | |
11179 | ||
11180 | import from TempA all; | |
11181 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
11182 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
11183 | ||
11184 | const BERPDU b := first | |
11185 | ||
11186 | <TTCN_TC:EXEC> | |
11187 | ||
11188 | if ((enc_DER_PDU(b) == '0A0101'O)and(enc_CER_PDU(b) == '0A0101'O)) {setverdict(pass);} else {setverdict(fail);} | |
11189 | ||
11190 | <RESULT> | |
11191 | ||
11192 | Overall verdict: pass | |
11193 | ||
11194 | <END_TC> | |
11195 | ||
11196 | :exmp. | |
11197 | ||
11198 | .*---------------------------------------------------------------------* | |
11199 | :h3. DER + CER encoding of ENUMERATED second(0) | |
11200 | .*---------------------------------------------------------------------* | |
11201 | :xmp tab=0. | |
11202 | ||
11203 | <TC - DER + CER encoding of ENUMERATED second(0)> | |
11204 | ||
11205 | <STATIC:ASN> | |
11206 | ||
11207 | TempA | |
11208 | ||
11209 | DEFINITIONS ::= | |
11210 | BEGIN | |
11211 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11212 | END | |
11213 | ||
11214 | <STATIC> | |
11215 | ||
11216 | import from TempA all; | |
11217 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
11218 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
11219 | ||
11220 | const BERPDU b := second | |
11221 | ||
11222 | <TTCN_TC:EXEC> | |
11223 | ||
11224 | if ((enc_DER_PDU(b) == '0A0100'O)and(enc_CER_PDU(b) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);} | |
11225 | ||
11226 | <RESULT> | |
11227 | ||
11228 | Overall verdict: pass | |
11229 | ||
11230 | <END_TC> | |
11231 | ||
11232 | :exmp. | |
11233 | ||
11234 | .*---------------------------------------------------------------------* | |
11235 | :h3. DER + CER encoding of ENUMERATED third | |
11236 | .*---------------------------------------------------------------------* | |
11237 | :xmp tab=0. | |
11238 | ||
11239 | <TC - DER + CER encoding of ENUMERATED third> | |
11240 | ||
11241 | <STATIC:ASN> | |
11242 | ||
11243 | TempA | |
11244 | ||
11245 | DEFINITIONS ::= | |
11246 | BEGIN | |
11247 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11248 | END | |
11249 | ||
11250 | <STATIC> | |
11251 | ||
11252 | import from TempA all; | |
11253 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
11254 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
11255 | ||
11256 | const BERPDU b := third | |
11257 | ||
11258 | <TTCN_TC:EXEC> | |
11259 | ||
11260 | if ((enc_DER_PDU(b) == '0A0102'O)and(enc_CER_PDU(b) == '0A0102'O)) {setverdict(pass);} else {setverdict(fail);} | |
11261 | ||
11262 | <RESULT> | |
11263 | ||
11264 | Overall verdict: pass | |
11265 | ||
11266 | <END_TC> | |
11267 | ||
11268 | :exmp. | |
11269 | ||
11270 | .*---------------------------------------------------------------------* | |
11271 | :h3. DER + CER encoding of ENUMERATED fourth (after extension ...) | |
11272 | .*---------------------------------------------------------------------* | |
11273 | :xmp tab=0. | |
11274 | ||
11275 | <TC - DER + CER encoding of ENUMERATED fourth (after extension ...)> | |
11276 | ||
11277 | <STATIC:ASN> | |
11278 | ||
11279 | TempA | |
11280 | ||
11281 | DEFINITIONS ::= | |
11282 | BEGIN | |
11283 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11284 | END | |
11285 | ||
11286 | <STATIC> | |
11287 | ||
11288 | import from TempA all; | |
11289 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
11290 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
11291 | ||
11292 | const BERPDU b := fourth | |
11293 | ||
11294 | <TTCN_TC:EXEC> | |
11295 | ||
11296 | if ((enc_DER_PDU(b) == '0A0103'O)and(enc_CER_PDU(b) == '0A0103'O)) {setverdict(pass);} else {setverdict(fail);} | |
11297 | ||
11298 | <RESULT> | |
11299 | ||
11300 | Overall verdict: pass | |
11301 | ||
11302 | <END_TC> | |
11303 | ||
11304 | :exmp. | |
11305 | ||
11306 | .*---------------------------------------------------------------------* | |
11307 | :h3. DER + CER encoding of ENUMERATED fifth(5) (after extension ...) | |
11308 | .*---------------------------------------------------------------------* | |
11309 | :xmp tab=0. | |
11310 | ||
11311 | <TC - DER + CER encoding of ENUMERATED fifth(5) (after extension ...)> | |
11312 | ||
11313 | <STATIC:ASN> | |
11314 | ||
11315 | TempA | |
11316 | ||
11317 | DEFINITIONS ::= | |
11318 | BEGIN | |
11319 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11320 | END | |
11321 | ||
11322 | <STATIC> | |
11323 | ||
11324 | import from TempA all; | |
11325 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
11326 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
11327 | ||
11328 | const BERPDU b := fifth | |
11329 | ||
11330 | <TTCN_TC:EXEC> | |
11331 | ||
11332 | if ((enc_DER_PDU(b) == '0A0105'O)and(enc_CER_PDU(b) == '0A0105'O)) {setverdict(pass);} else {setverdict(fail);} | |
11333 | ||
11334 | <RESULT> | |
11335 | ||
11336 | Overall verdict: pass | |
11337 | ||
11338 | <END_TC> | |
11339 | ||
11340 | :exmp. | |
11341 | ||
11342 | .*---------------------------------------------------------------------* | |
11343 | :h3. DER + CER encoding of ENUMERATED sixth (after extension ...) | |
11344 | .*---------------------------------------------------------------------* | |
11345 | :xmp tab=0. | |
11346 | ||
11347 | <TC - DER + CER encoding of ENUMERATED sixth (after extension ...)> | |
11348 | ||
11349 | <STATIC:ASN> | |
11350 | ||
11351 | TempA | |
11352 | ||
11353 | DEFINITIONS ::= | |
11354 | BEGIN | |
11355 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11356 | END | |
11357 | ||
11358 | <STATIC> | |
11359 | ||
11360 | import from TempA all; | |
11361 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
11362 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
11363 | ||
11364 | const BERPDU b := sixth | |
11365 | ||
11366 | <TTCN_TC:EXEC> | |
11367 | ||
11368 | if ((enc_DER_PDU(b) == '0A0106'O)and(enc_CER_PDU(b) == '0A0106'O)) {setverdict(pass);} else {setverdict(fail);} | |
11369 | ||
11370 | <RESULT> | |
11371 | ||
11372 | Overall verdict: pass | |
11373 | ||
11374 | <END_TC> | |
11375 | ||
11376 | :exmp. | |
11377 | ||
11378 | .*---------------------------------------------------------------------* | |
11379 | :h3. DER + CER encoding of ENUMERATED , tagged, EXPLICIT | |
11380 | .*---------------------------------------------------------------------* | |
11381 | :xmp tab=0. | |
11382 | ||
11383 | <TC - DER + CER encoding of ENUMERATED , tagged, EXPLICIT> | |
11384 | ||
11385 | <STATIC:ASN> | |
11386 | ||
11387 | TempA | |
11388 | ||
11389 | DEFINITIONS ::= | |
11390 | BEGIN | |
11391 | BERPDU ::= [21] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11392 | END | |
11393 | ||
11394 | <STATIC> | |
11395 | ||
11396 | import from TempA all; | |
11397 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
11398 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
11399 | ||
11400 | const BERPDU b := sixth | |
11401 | ||
11402 | <TTCN_TC:EXEC> | |
11403 | ||
11404 | if ((enc_DER_PDU(b) == 'B5030A0106'O)and(enc_CER_PDU(b) == 'B5800A01060000'O)) {setverdict(pass);} else {setverdict(fail);} | |
11405 | ||
11406 | <RESULT> | |
11407 | ||
11408 | Overall verdict: pass | |
11409 | ||
11410 | <END_TC> | |
11411 | ||
11412 | :exmp. | |
11413 | ||
11414 | .*---------------------------------------------------------------------* | |
11415 | :h3. DER + CER encoding of ENUMERATED , tagged, IMPLICIT | |
11416 | .*---------------------------------------------------------------------* | |
11417 | :xmp tab=0. | |
11418 | ||
11419 | <TC - DER + CER encoding of ENUMERATED , tagged, IMPLICIT> | |
11420 | ||
11421 | <STATIC:ASN> | |
11422 | ||
11423 | TempA | |
11424 | ||
11425 | DEFINITIONS ::= | |
11426 | BEGIN | |
11427 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11428 | END | |
11429 | ||
11430 | <STATIC> | |
11431 | ||
11432 | import from TempA all; | |
11433 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
11434 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
11435 | ||
11436 | const BERPDU b := sixth | |
11437 | ||
11438 | <TTCN_TC:EXEC> | |
11439 | ||
11440 | if ((enc_DER_PDU(b) == '9F580106'O)and(enc_CER_PDU(b) == '9F580106'O)) {setverdict(pass);} else {setverdict(fail);} | |
11441 | ||
11442 | <RESULT> | |
11443 | ||
11444 | Overall verdict: pass | |
11445 | ||
11446 | <END_TC> | |
11447 | ||
11448 | :exmp. | |
11449 | ||
11450 | .*---------------------------------------------------------------------* | |
11451 | :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (first) | |
11452 | .*---------------------------------------------------------------------* | |
11453 | :xmp tab=0. | |
11454 | ||
11455 | <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (first)> | |
11456 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11457 | ||
11458 | <STATIC:ASN> | |
11459 | ||
11460 | TempA | |
11461 | ||
11462 | DEFINITIONS ::= | |
11463 | BEGIN | |
11464 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11465 | ||
11466 | ||
11467 | myValue BERPDU ::= first | |
11468 | ||
11469 | ||
11470 | ||
11471 | END | |
11472 | ||
11473 | <STATIC> | |
11474 | ||
11475 | import from TempA all; | |
11476 | ||
11477 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
11478 | ||
11479 | ||
11480 | <TTCN_TC:EXEC> | |
11481 | ||
11482 | if (dec_BER_PDU('0A0101'O) == myValue) | |
11483 | ||
11484 | {setverdict(pass);} else {setverdict(fail);} | |
11485 | ||
11486 | ||
11487 | <RESULT> | |
11488 | ||
11489 | Overall verdict: pass | |
11490 | ||
11491 | <END_TC> | |
11492 | ||
11493 | :exmp. | |
11494 | ||
11495 | .*---------------------------------------------------------------------* | |
11496 | :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (first) | |
11497 | .*---------------------------------------------------------------------* | |
11498 | :xmp tab=0. | |
11499 | ||
11500 | <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (first)> | |
11501 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11502 | ||
11503 | <STATIC:ASN> | |
11504 | ||
11505 | TempA | |
11506 | ||
11507 | DEFINITIONS ::= | |
11508 | BEGIN | |
11509 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11510 | ||
11511 | ||
11512 | myValue BERPDU ::= first | |
11513 | ||
11514 | ||
11515 | ||
11516 | END | |
11517 | ||
11518 | <STATIC> | |
11519 | ||
11520 | import from TempA all; | |
11521 | ||
11522 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
11523 | ||
11524 | ||
11525 | <TTCN_TC:EXEC> | |
11526 | ||
11527 | if (dec_BER_PDU('0A810101'O) == myValue) | |
11528 | ||
11529 | {setverdict(pass);} else {setverdict(fail);} | |
11530 | ||
11531 | ||
11532 | <RESULT> | |
11533 | ||
11534 | Overall verdict: pass | |
11535 | ||
11536 | <END_TC> | |
11537 | ||
11538 | :exmp. | |
11539 | ||
11540 | .*---------------------------------------------------------------------* | |
11541 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (first) | |
11542 | .*---------------------------------------------------------------------* | |
11543 | :xmp tab=0. | |
11544 | ||
11545 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (first)> | |
11546 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11547 | ||
11548 | <STATIC:ASN> | |
11549 | ||
11550 | TempA | |
11551 | ||
11552 | DEFINITIONS ::= | |
11553 | BEGIN | |
11554 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11555 | ||
11556 | ||
11557 | myValue BERPDU ::= first | |
11558 | ||
11559 | ||
11560 | ||
11561 | END | |
11562 | ||
11563 | <STATIC> | |
11564 | ||
11565 | import from TempA all; | |
11566 | ||
11567 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
11568 | ||
11569 | ||
11570 | <TTCN_TC:EXEC> | |
11571 | ||
11572 | if (dec_BER_PDU('A0030A0101'O) == myValue) | |
11573 | ||
11574 | {setverdict(pass);} else {setverdict(fail);} | |
11575 | ||
11576 | ||
11577 | <RESULT> | |
11578 | ||
11579 | Overall verdict: pass | |
11580 | ||
11581 | <END_TC> | |
11582 | ||
11583 | :exmp. | |
11584 | ||
11585 | .*---------------------------------------------------------------------* | |
11586 | :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (first) | |
11587 | .*---------------------------------------------------------------------* | |
11588 | :xmp tab=0. | |
11589 | ||
11590 | <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (first)> | |
11591 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11592 | ||
11593 | <STATIC:ASN> | |
11594 | ||
11595 | TempA | |
11596 | ||
11597 | DEFINITIONS ::= | |
11598 | BEGIN | |
11599 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11600 | ||
11601 | ||
11602 | myValue BERPDU ::= first | |
11603 | ||
11604 | ||
11605 | ||
11606 | END | |
11607 | ||
11608 | <STATIC> | |
11609 | ||
11610 | import from TempA all; | |
11611 | ||
11612 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
11613 | ||
11614 | ||
11615 | <TTCN_TC:EXEC> | |
11616 | ||
11617 | if (dec_BER_PDU('A0800A01010000'O) == myValue) | |
11618 | ||
11619 | {setverdict(pass);} else {setverdict(fail);} | |
11620 | ||
11621 | ||
11622 | <RESULT> | |
11623 | ||
11624 | Overall verdict: pass | |
11625 | ||
11626 | <END_TC> | |
11627 | ||
11628 | :exmp. | |
11629 | ||
11630 | .*---------------------------------------------------------------------* | |
11631 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (first) | |
11632 | .*---------------------------------------------------------------------* | |
11633 | :xmp tab=0. | |
11634 | ||
11635 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (first)> | |
11636 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11637 | ||
11638 | <STATIC:ASN> | |
11639 | ||
11640 | TempA | |
11641 | ||
11642 | DEFINITIONS ::= | |
11643 | BEGIN | |
11644 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11645 | ||
11646 | ||
11647 | myValue BERPDU ::= first | |
11648 | ||
11649 | ||
11650 | ||
11651 | END | |
11652 | ||
11653 | <STATIC> | |
11654 | ||
11655 | import from TempA all; | |
11656 | ||
11657 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
11658 | ||
11659 | ||
11660 | <TTCN_TC:EXEC> | |
11661 | ||
11662 | if (dec_BER_PDU('A0040A810101'O) == myValue) | |
11663 | ||
11664 | {setverdict(pass);} else {setverdict(fail);} | |
11665 | ||
11666 | ||
11667 | <RESULT> | |
11668 | ||
11669 | Overall verdict: pass | |
11670 | ||
11671 | <END_TC> | |
11672 | ||
11673 | :exmp. | |
11674 | ||
11675 | .*---------------------------------------------------------------------* | |
11676 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (first) | |
11677 | .*---------------------------------------------------------------------* | |
11678 | :xmp tab=0. | |
11679 | ||
11680 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (first)> | |
11681 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11682 | ||
11683 | <STATIC:ASN> | |
11684 | ||
11685 | TempA | |
11686 | ||
11687 | DEFINITIONS ::= | |
11688 | BEGIN | |
11689 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11690 | ||
11691 | ||
11692 | myValue BERPDU ::= first | |
11693 | ||
11694 | ||
11695 | ||
11696 | END | |
11697 | ||
11698 | <STATIC> | |
11699 | ||
11700 | import from TempA all; | |
11701 | ||
11702 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
11703 | ||
11704 | ||
11705 | <TTCN_TC:EXEC> | |
11706 | ||
11707 | if (dec_BER_PDU('A081040A810101'O) == myValue) | |
11708 | ||
11709 | {setverdict(pass);} else {setverdict(fail);} | |
11710 | ||
11711 | ||
11712 | <RESULT> | |
11713 | ||
11714 | Overall verdict: pass | |
11715 | ||
11716 | <END_TC> | |
11717 | ||
11718 | :exmp. | |
11719 | ||
11720 | .*---------------------------------------------------------------------* | |
11721 | :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (first) | |
11722 | .*---------------------------------------------------------------------* | |
11723 | :xmp tab=0. | |
11724 | ||
11725 | <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (first)> | |
11726 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11727 | ||
11728 | <STATIC:ASN> | |
11729 | ||
11730 | TempA | |
11731 | ||
11732 | DEFINITIONS ::= | |
11733 | BEGIN | |
11734 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11735 | ||
11736 | ||
11737 | myValue BERPDU ::= first | |
11738 | ||
11739 | ||
11740 | ||
11741 | END | |
11742 | ||
11743 | <STATIC> | |
11744 | ||
11745 | import from TempA all; | |
11746 | ||
11747 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
11748 | ||
11749 | ||
11750 | <TTCN_TC:EXEC> | |
11751 | ||
11752 | if (dec_BER_PDU('9F580101'O) == myValue) | |
11753 | ||
11754 | {setverdict(pass);} else {setverdict(fail);} | |
11755 | ||
11756 | ||
11757 | <RESULT> | |
11758 | ||
11759 | Overall verdict: pass | |
11760 | ||
11761 | <END_TC> | |
11762 | ||
11763 | :exmp. | |
11764 | ||
11765 | .*---------------------------------------------------------------------* | |
11766 | :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (first) | |
11767 | .*---------------------------------------------------------------------* | |
11768 | :xmp tab=0. | |
11769 | ||
11770 | <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (first)> | |
11771 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11772 | ||
11773 | <STATIC:ASN> | |
11774 | ||
11775 | TempA | |
11776 | ||
11777 | DEFINITIONS ::= | |
11778 | BEGIN | |
11779 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11780 | ||
11781 | ||
11782 | myValue BERPDU ::= first | |
11783 | ||
11784 | ||
11785 | ||
11786 | END | |
11787 | ||
11788 | <STATIC> | |
11789 | ||
11790 | import from TempA all; | |
11791 | ||
11792 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
11793 | ||
11794 | ||
11795 | <TTCN_TC:EXEC> | |
11796 | ||
11797 | if (dec_BER_PDU('9F58810101'O) == myValue) | |
11798 | ||
11799 | {setverdict(pass);} else {setverdict(fail);} | |
11800 | ||
11801 | ||
11802 | <RESULT> | |
11803 | ||
11804 | Overall verdict: pass | |
11805 | ||
11806 | <END_TC> | |
11807 | ||
11808 | :exmp. | |
11809 | ||
11810 | .*---------------------------------------------------------------------* | |
11811 | :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (second(0)) | |
11812 | .*---------------------------------------------------------------------* | |
11813 | :xmp tab=0. | |
11814 | ||
11815 | <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (second(0))> | |
11816 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11817 | ||
11818 | <STATIC:ASN> | |
11819 | ||
11820 | TempA | |
11821 | ||
11822 | DEFINITIONS ::= | |
11823 | BEGIN | |
11824 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11825 | ||
11826 | ||
11827 | myValue BERPDU ::= second | |
11828 | ||
11829 | ||
11830 | ||
11831 | END | |
11832 | ||
11833 | <STATIC> | |
11834 | ||
11835 | import from TempA all; | |
11836 | ||
11837 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
11838 | ||
11839 | ||
11840 | <TTCN_TC:EXEC> | |
11841 | ||
11842 | if (dec_BER_PDU('0A0100'O) == myValue) | |
11843 | ||
11844 | {setverdict(pass);} else {setverdict(fail);} | |
11845 | ||
11846 | ||
11847 | <RESULT> | |
11848 | ||
11849 | Overall verdict: pass | |
11850 | ||
11851 | <END_TC> | |
11852 | ||
11853 | :exmp. | |
11854 | ||
11855 | .*---------------------------------------------------------------------* | |
11856 | :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (second(0)) | |
11857 | .*---------------------------------------------------------------------* | |
11858 | :xmp tab=0. | |
11859 | ||
11860 | <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (second(0))> | |
11861 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11862 | ||
11863 | <STATIC:ASN> | |
11864 | ||
11865 | TempA | |
11866 | ||
11867 | DEFINITIONS ::= | |
11868 | BEGIN | |
11869 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11870 | ||
11871 | ||
11872 | myValue BERPDU ::= second | |
11873 | ||
11874 | ||
11875 | ||
11876 | END | |
11877 | ||
11878 | <STATIC> | |
11879 | ||
11880 | import from TempA all; | |
11881 | ||
11882 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
11883 | ||
11884 | ||
11885 | <TTCN_TC:EXEC> | |
11886 | ||
11887 | if (dec_BER_PDU('0A810100'O) == myValue) | |
11888 | ||
11889 | {setverdict(pass);} else {setverdict(fail);} | |
11890 | ||
11891 | ||
11892 | <RESULT> | |
11893 | ||
11894 | Overall verdict: pass | |
11895 | ||
11896 | <END_TC> | |
11897 | ||
11898 | :exmp. | |
11899 | ||
11900 | .*---------------------------------------------------------------------* | |
11901 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (second(0)) | |
11902 | .*---------------------------------------------------------------------* | |
11903 | :xmp tab=0. | |
11904 | ||
11905 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (second(0))> | |
11906 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11907 | ||
11908 | <STATIC:ASN> | |
11909 | ||
11910 | TempA | |
11911 | ||
11912 | DEFINITIONS ::= | |
11913 | BEGIN | |
11914 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11915 | ||
11916 | ||
11917 | myValue BERPDU ::= second | |
11918 | ||
11919 | ||
11920 | ||
11921 | END | |
11922 | ||
11923 | <STATIC> | |
11924 | ||
11925 | import from TempA all; | |
11926 | ||
11927 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
11928 | ||
11929 | ||
11930 | <TTCN_TC:EXEC> | |
11931 | ||
11932 | if (dec_BER_PDU('A0030A0100'O) == myValue) | |
11933 | ||
11934 | {setverdict(pass);} else {setverdict(fail);} | |
11935 | ||
11936 | ||
11937 | <RESULT> | |
11938 | ||
11939 | Overall verdict: pass | |
11940 | ||
11941 | <END_TC> | |
11942 | ||
11943 | :exmp. | |
11944 | ||
11945 | .*---------------------------------------------------------------------* | |
11946 | :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (second(0)) | |
11947 | .*---------------------------------------------------------------------* | |
11948 | :xmp tab=0. | |
11949 | ||
11950 | <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (second(0))> | |
11951 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11952 | ||
11953 | <STATIC:ASN> | |
11954 | ||
11955 | TempA | |
11956 | ||
11957 | DEFINITIONS ::= | |
11958 | BEGIN | |
11959 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11960 | ||
11961 | ||
11962 | myValue BERPDU ::= second | |
11963 | ||
11964 | ||
11965 | ||
11966 | END | |
11967 | ||
11968 | <STATIC> | |
11969 | ||
11970 | import from TempA all; | |
11971 | ||
11972 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
11973 | ||
11974 | ||
11975 | <TTCN_TC:EXEC> | |
11976 | ||
11977 | if (dec_BER_PDU('A0800A01000000'O) == myValue) | |
11978 | ||
11979 | {setverdict(pass);} else {setverdict(fail);} | |
11980 | ||
11981 | ||
11982 | <RESULT> | |
11983 | ||
11984 | Overall verdict: pass | |
11985 | ||
11986 | <END_TC> | |
11987 | ||
11988 | :exmp. | |
11989 | ||
11990 | .*---------------------------------------------------------------------* | |
11991 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (second(0)) | |
11992 | .*---------------------------------------------------------------------* | |
11993 | :xmp tab=0. | |
11994 | ||
11995 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (second(0))> | |
11996 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
11997 | ||
11998 | <STATIC:ASN> | |
11999 | ||
12000 | TempA | |
12001 | ||
12002 | DEFINITIONS ::= | |
12003 | BEGIN | |
12004 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12005 | ||
12006 | ||
12007 | myValue BERPDU ::= second | |
12008 | ||
12009 | ||
12010 | ||
12011 | END | |
12012 | ||
12013 | <STATIC> | |
12014 | ||
12015 | import from TempA all; | |
12016 | ||
12017 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12018 | ||
12019 | ||
12020 | <TTCN_TC:EXEC> | |
12021 | ||
12022 | if (dec_BER_PDU('A0040A810100'O) == myValue) | |
12023 | ||
12024 | {setverdict(pass);} else {setverdict(fail);} | |
12025 | ||
12026 | ||
12027 | <RESULT> | |
12028 | ||
12029 | Overall verdict: pass | |
12030 | ||
12031 | <END_TC> | |
12032 | ||
12033 | :exmp. | |
12034 | ||
12035 | .*---------------------------------------------------------------------* | |
12036 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (second(0)) | |
12037 | .*---------------------------------------------------------------------* | |
12038 | :xmp tab=0. | |
12039 | ||
12040 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (second(0))> | |
12041 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12042 | ||
12043 | <STATIC:ASN> | |
12044 | ||
12045 | TempA | |
12046 | ||
12047 | DEFINITIONS ::= | |
12048 | BEGIN | |
12049 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12050 | ||
12051 | ||
12052 | myValue BERPDU ::= second | |
12053 | ||
12054 | ||
12055 | ||
12056 | END | |
12057 | ||
12058 | <STATIC> | |
12059 | ||
12060 | import from TempA all; | |
12061 | ||
12062 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12063 | ||
12064 | ||
12065 | <TTCN_TC:EXEC> | |
12066 | ||
12067 | if (dec_BER_PDU('A081040A810100'O) == myValue) | |
12068 | ||
12069 | {setverdict(pass);} else {setverdict(fail);} | |
12070 | ||
12071 | ||
12072 | <RESULT> | |
12073 | ||
12074 | Overall verdict: pass | |
12075 | ||
12076 | <END_TC> | |
12077 | ||
12078 | :exmp. | |
12079 | ||
12080 | .*---------------------------------------------------------------------* | |
12081 | :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (second(0)) | |
12082 | .*---------------------------------------------------------------------* | |
12083 | :xmp tab=0. | |
12084 | ||
12085 | <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (second(0))> | |
12086 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12087 | ||
12088 | <STATIC:ASN> | |
12089 | ||
12090 | TempA | |
12091 | ||
12092 | DEFINITIONS ::= | |
12093 | BEGIN | |
12094 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12095 | ||
12096 | ||
12097 | myValue BERPDU ::= second | |
12098 | ||
12099 | ||
12100 | ||
12101 | END | |
12102 | ||
12103 | <STATIC> | |
12104 | ||
12105 | import from TempA all; | |
12106 | ||
12107 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12108 | ||
12109 | ||
12110 | <TTCN_TC:EXEC> | |
12111 | ||
12112 | if (dec_BER_PDU('9F580100'O) == myValue) | |
12113 | ||
12114 | {setverdict(pass);} else {setverdict(fail);} | |
12115 | ||
12116 | ||
12117 | <RESULT> | |
12118 | ||
12119 | Overall verdict: pass | |
12120 | ||
12121 | <END_TC> | |
12122 | ||
12123 | :exmp. | |
12124 | ||
12125 | .*---------------------------------------------------------------------* | |
12126 | :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (second(0)) | |
12127 | .*---------------------------------------------------------------------* | |
12128 | :xmp tab=0. | |
12129 | ||
12130 | <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (second(0))> | |
12131 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12132 | ||
12133 | <STATIC:ASN> | |
12134 | ||
12135 | TempA | |
12136 | ||
12137 | DEFINITIONS ::= | |
12138 | BEGIN | |
12139 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12140 | ||
12141 | ||
12142 | myValue BERPDU ::= second | |
12143 | ||
12144 | ||
12145 | ||
12146 | END | |
12147 | ||
12148 | <STATIC> | |
12149 | ||
12150 | import from TempA all; | |
12151 | ||
12152 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12153 | ||
12154 | ||
12155 | <TTCN_TC:EXEC> | |
12156 | ||
12157 | if (dec_BER_PDU('9F58810100'O) == myValue) | |
12158 | ||
12159 | {setverdict(pass);} else {setverdict(fail);} | |
12160 | ||
12161 | ||
12162 | <RESULT> | |
12163 | ||
12164 | Overall verdict: pass | |
12165 | ||
12166 | <END_TC> | |
12167 | ||
12168 | :exmp. | |
12169 | ||
12170 | .*---------------------------------------------------------------------* | |
12171 | :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (third) | |
12172 | .*---------------------------------------------------------------------* | |
12173 | :xmp tab=0. | |
12174 | ||
12175 | <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (third)> | |
12176 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12177 | ||
12178 | <STATIC:ASN> | |
12179 | ||
12180 | TempA | |
12181 | ||
12182 | DEFINITIONS ::= | |
12183 | BEGIN | |
12184 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12185 | ||
12186 | ||
12187 | myValue BERPDU ::= third | |
12188 | ||
12189 | ||
12190 | ||
12191 | END | |
12192 | ||
12193 | <STATIC> | |
12194 | ||
12195 | import from TempA all; | |
12196 | ||
12197 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12198 | ||
12199 | ||
12200 | <TTCN_TC:EXEC> | |
12201 | ||
12202 | if (dec_BER_PDU('0A0102'O) == myValue) | |
12203 | ||
12204 | {setverdict(pass);} else {setverdict(fail);} | |
12205 | ||
12206 | ||
12207 | <RESULT> | |
12208 | ||
12209 | Overall verdict: pass | |
12210 | ||
12211 | <END_TC> | |
12212 | ||
12213 | :exmp. | |
12214 | ||
12215 | .*---------------------------------------------------------------------* | |
12216 | :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (third) | |
12217 | .*---------------------------------------------------------------------* | |
12218 | :xmp tab=0. | |
12219 | ||
12220 | <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (third)> | |
12221 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12222 | ||
12223 | <STATIC:ASN> | |
12224 | ||
12225 | TempA | |
12226 | ||
12227 | DEFINITIONS ::= | |
12228 | BEGIN | |
12229 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12230 | ||
12231 | ||
12232 | myValue BERPDU ::= third | |
12233 | ||
12234 | ||
12235 | ||
12236 | END | |
12237 | ||
12238 | <STATIC> | |
12239 | ||
12240 | import from TempA all; | |
12241 | ||
12242 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12243 | ||
12244 | ||
12245 | <TTCN_TC:EXEC> | |
12246 | ||
12247 | if (dec_BER_PDU('0A810102'O) == myValue) | |
12248 | ||
12249 | {setverdict(pass);} else {setverdict(fail);} | |
12250 | ||
12251 | ||
12252 | <RESULT> | |
12253 | ||
12254 | Overall verdict: pass | |
12255 | ||
12256 | <END_TC> | |
12257 | ||
12258 | :exmp. | |
12259 | ||
12260 | .*---------------------------------------------------------------------* | |
12261 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (third) | |
12262 | .*---------------------------------------------------------------------* | |
12263 | :xmp tab=0. | |
12264 | ||
12265 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (third)> | |
12266 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12267 | ||
12268 | <STATIC:ASN> | |
12269 | ||
12270 | TempA | |
12271 | ||
12272 | DEFINITIONS ::= | |
12273 | BEGIN | |
12274 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12275 | ||
12276 | ||
12277 | myValue BERPDU ::= third | |
12278 | ||
12279 | ||
12280 | ||
12281 | END | |
12282 | ||
12283 | <STATIC> | |
12284 | ||
12285 | import from TempA all; | |
12286 | ||
12287 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12288 | ||
12289 | ||
12290 | <TTCN_TC:EXEC> | |
12291 | ||
12292 | if (dec_BER_PDU('A0030A0102'O) == myValue) | |
12293 | ||
12294 | {setverdict(pass);} else {setverdict(fail);} | |
12295 | ||
12296 | ||
12297 | <RESULT> | |
12298 | ||
12299 | Overall verdict: pass | |
12300 | ||
12301 | <END_TC> | |
12302 | ||
12303 | :exmp. | |
12304 | ||
12305 | .*---------------------------------------------------------------------* | |
12306 | :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (third) | |
12307 | .*---------------------------------------------------------------------* | |
12308 | :xmp tab=0. | |
12309 | ||
12310 | <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (third)> | |
12311 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12312 | ||
12313 | <STATIC:ASN> | |
12314 | ||
12315 | TempA | |
12316 | ||
12317 | DEFINITIONS ::= | |
12318 | BEGIN | |
12319 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12320 | ||
12321 | ||
12322 | myValue BERPDU ::= third | |
12323 | ||
12324 | ||
12325 | ||
12326 | END | |
12327 | ||
12328 | <STATIC> | |
12329 | ||
12330 | import from TempA all; | |
12331 | ||
12332 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12333 | ||
12334 | ||
12335 | <TTCN_TC:EXEC> | |
12336 | ||
12337 | if (dec_BER_PDU('A0800A01020000'O) == myValue) | |
12338 | ||
12339 | {setverdict(pass);} else {setverdict(fail);} | |
12340 | ||
12341 | ||
12342 | <RESULT> | |
12343 | ||
12344 | Overall verdict: pass | |
12345 | ||
12346 | <END_TC> | |
12347 | ||
12348 | :exmp. | |
12349 | ||
12350 | .*---------------------------------------------------------------------* | |
12351 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (third) | |
12352 | .*---------------------------------------------------------------------* | |
12353 | :xmp tab=0. | |
12354 | ||
12355 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (third)> | |
12356 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12357 | ||
12358 | <STATIC:ASN> | |
12359 | ||
12360 | TempA | |
12361 | ||
12362 | DEFINITIONS ::= | |
12363 | BEGIN | |
12364 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12365 | ||
12366 | ||
12367 | myValue BERPDU ::= third | |
12368 | ||
12369 | ||
12370 | ||
12371 | END | |
12372 | ||
12373 | <STATIC> | |
12374 | ||
12375 | import from TempA all; | |
12376 | ||
12377 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12378 | ||
12379 | ||
12380 | <TTCN_TC:EXEC> | |
12381 | ||
12382 | if (dec_BER_PDU('A0040A810102'O) == myValue) | |
12383 | ||
12384 | {setverdict(pass);} else {setverdict(fail);} | |
12385 | ||
12386 | ||
12387 | <RESULT> | |
12388 | ||
12389 | Overall verdict: pass | |
12390 | ||
12391 | <END_TC> | |
12392 | ||
12393 | :exmp. | |
12394 | ||
12395 | .*---------------------------------------------------------------------* | |
12396 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (third) | |
12397 | .*---------------------------------------------------------------------* | |
12398 | :xmp tab=0. | |
12399 | ||
12400 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (third)> | |
12401 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12402 | ||
12403 | <STATIC:ASN> | |
12404 | ||
12405 | TempA | |
12406 | ||
12407 | DEFINITIONS ::= | |
12408 | BEGIN | |
12409 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12410 | ||
12411 | ||
12412 | myValue BERPDU ::= third | |
12413 | ||
12414 | ||
12415 | ||
12416 | END | |
12417 | ||
12418 | <STATIC> | |
12419 | ||
12420 | import from TempA all; | |
12421 | ||
12422 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12423 | ||
12424 | ||
12425 | <TTCN_TC:EXEC> | |
12426 | ||
12427 | if (dec_BER_PDU('A081040A810102'O) == myValue) | |
12428 | ||
12429 | {setverdict(pass);} else {setverdict(fail);} | |
12430 | ||
12431 | ||
12432 | <RESULT> | |
12433 | ||
12434 | Overall verdict: pass | |
12435 | ||
12436 | <END_TC> | |
12437 | ||
12438 | :exmp. | |
12439 | ||
12440 | .*---------------------------------------------------------------------* | |
12441 | :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (third) | |
12442 | .*---------------------------------------------------------------------* | |
12443 | :xmp tab=0. | |
12444 | ||
12445 | <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (third)> | |
12446 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12447 | ||
12448 | <STATIC:ASN> | |
12449 | ||
12450 | TempA | |
12451 | ||
12452 | DEFINITIONS ::= | |
12453 | BEGIN | |
12454 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12455 | ||
12456 | ||
12457 | myValue BERPDU ::= third | |
12458 | ||
12459 | ||
12460 | ||
12461 | END | |
12462 | ||
12463 | <STATIC> | |
12464 | ||
12465 | import from TempA all; | |
12466 | ||
12467 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12468 | ||
12469 | ||
12470 | <TTCN_TC:EXEC> | |
12471 | ||
12472 | if (dec_BER_PDU('9F580102'O) == myValue) | |
12473 | ||
12474 | {setverdict(pass);} else {setverdict(fail);} | |
12475 | ||
12476 | ||
12477 | <RESULT> | |
12478 | ||
12479 | Overall verdict: pass | |
12480 | ||
12481 | <END_TC> | |
12482 | ||
12483 | :exmp. | |
12484 | ||
12485 | .*---------------------------------------------------------------------* | |
12486 | :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (third) | |
12487 | .*---------------------------------------------------------------------* | |
12488 | :xmp tab=0. | |
12489 | ||
12490 | <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (third)> | |
12491 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12492 | ||
12493 | <STATIC:ASN> | |
12494 | ||
12495 | TempA | |
12496 | ||
12497 | DEFINITIONS ::= | |
12498 | BEGIN | |
12499 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12500 | ||
12501 | ||
12502 | myValue BERPDU ::= third | |
12503 | ||
12504 | ||
12505 | ||
12506 | END | |
12507 | ||
12508 | <STATIC> | |
12509 | ||
12510 | import from TempA all; | |
12511 | ||
12512 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12513 | ||
12514 | ||
12515 | <TTCN_TC:EXEC> | |
12516 | ||
12517 | if (dec_BER_PDU('9F58810102'O) == myValue) | |
12518 | ||
12519 | {setverdict(pass);} else {setverdict(fail);} | |
12520 | ||
12521 | ||
12522 | <RESULT> | |
12523 | ||
12524 | Overall verdict: pass | |
12525 | ||
12526 | <END_TC> | |
12527 | ||
12528 | :exmp. | |
12529 | ||
12530 | .*---------------------------------------------------------------------* | |
12531 | :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (fourth) | |
12532 | .*---------------------------------------------------------------------* | |
12533 | :xmp tab=0. | |
12534 | ||
12535 | <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (fourth)> | |
12536 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12537 | ||
12538 | <STATIC:ASN> | |
12539 | ||
12540 | TempA | |
12541 | ||
12542 | DEFINITIONS ::= | |
12543 | BEGIN | |
12544 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12545 | ||
12546 | ||
12547 | myValue BERPDU ::= fourth | |
12548 | ||
12549 | ||
12550 | ||
12551 | END | |
12552 | ||
12553 | <STATIC> | |
12554 | ||
12555 | import from TempA all; | |
12556 | ||
12557 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12558 | ||
12559 | ||
12560 | <TTCN_TC:EXEC> | |
12561 | ||
12562 | if (dec_BER_PDU('0A0103'O) == myValue) | |
12563 | ||
12564 | {setverdict(pass);} else {setverdict(fail);} | |
12565 | ||
12566 | ||
12567 | <RESULT> | |
12568 | ||
12569 | Overall verdict: pass | |
12570 | ||
12571 | <END_TC> | |
12572 | ||
12573 | :exmp. | |
12574 | ||
12575 | .*---------------------------------------------------------------------* | |
12576 | :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (fourth) | |
12577 | .*---------------------------------------------------------------------* | |
12578 | :xmp tab=0. | |
12579 | ||
12580 | <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (fourth)> | |
12581 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12582 | ||
12583 | <STATIC:ASN> | |
12584 | ||
12585 | TempA | |
12586 | ||
12587 | DEFINITIONS ::= | |
12588 | BEGIN | |
12589 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12590 | ||
12591 | ||
12592 | myValue BERPDU ::= fourth | |
12593 | ||
12594 | ||
12595 | ||
12596 | END | |
12597 | ||
12598 | <STATIC> | |
12599 | ||
12600 | import from TempA all; | |
12601 | ||
12602 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12603 | ||
12604 | ||
12605 | <TTCN_TC:EXEC> | |
12606 | ||
12607 | if (dec_BER_PDU('0A810103'O) == myValue) | |
12608 | ||
12609 | {setverdict(pass);} else {setverdict(fail);} | |
12610 | ||
12611 | ||
12612 | <RESULT> | |
12613 | ||
12614 | Overall verdict: pass | |
12615 | ||
12616 | <END_TC> | |
12617 | ||
12618 | :exmp. | |
12619 | ||
12620 | .*---------------------------------------------------------------------* | |
12621 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (fourth) | |
12622 | .*---------------------------------------------------------------------* | |
12623 | :xmp tab=0. | |
12624 | ||
12625 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (fourth)> | |
12626 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12627 | ||
12628 | <STATIC:ASN> | |
12629 | ||
12630 | TempA | |
12631 | ||
12632 | DEFINITIONS ::= | |
12633 | BEGIN | |
12634 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12635 | ||
12636 | ||
12637 | myValue BERPDU ::= fourth | |
12638 | ||
12639 | ||
12640 | ||
12641 | END | |
12642 | ||
12643 | <STATIC> | |
12644 | ||
12645 | import from TempA all; | |
12646 | ||
12647 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12648 | ||
12649 | ||
12650 | <TTCN_TC:EXEC> | |
12651 | ||
12652 | if (dec_BER_PDU('A0030A0103'O) == myValue) | |
12653 | ||
12654 | {setverdict(pass);} else {setverdict(fail);} | |
12655 | ||
12656 | ||
12657 | <RESULT> | |
12658 | ||
12659 | Overall verdict: pass | |
12660 | ||
12661 | <END_TC> | |
12662 | ||
12663 | :exmp. | |
12664 | ||
12665 | .*---------------------------------------------------------------------* | |
12666 | :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (fourth) | |
12667 | .*---------------------------------------------------------------------* | |
12668 | :xmp tab=0. | |
12669 | ||
12670 | <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (fourth)> | |
12671 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12672 | ||
12673 | <STATIC:ASN> | |
12674 | ||
12675 | TempA | |
12676 | ||
12677 | DEFINITIONS ::= | |
12678 | BEGIN | |
12679 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12680 | ||
12681 | ||
12682 | myValue BERPDU ::= fourth | |
12683 | ||
12684 | ||
12685 | ||
12686 | END | |
12687 | ||
12688 | <STATIC> | |
12689 | ||
12690 | import from TempA all; | |
12691 | ||
12692 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12693 | ||
12694 | ||
12695 | <TTCN_TC:EXEC> | |
12696 | ||
12697 | if (dec_BER_PDU('A0800A01030000'O) == myValue) | |
12698 | ||
12699 | {setverdict(pass);} else {setverdict(fail);} | |
12700 | ||
12701 | ||
12702 | <RESULT> | |
12703 | ||
12704 | Overall verdict: pass | |
12705 | ||
12706 | <END_TC> | |
12707 | ||
12708 | :exmp. | |
12709 | ||
12710 | .*---------------------------------------------------------------------* | |
12711 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (fourth) | |
12712 | .*---------------------------------------------------------------------* | |
12713 | :xmp tab=0. | |
12714 | ||
12715 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (fourth)> | |
12716 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12717 | ||
12718 | <STATIC:ASN> | |
12719 | ||
12720 | TempA | |
12721 | ||
12722 | DEFINITIONS ::= | |
12723 | BEGIN | |
12724 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12725 | ||
12726 | ||
12727 | myValue BERPDU ::= fourth | |
12728 | ||
12729 | ||
12730 | ||
12731 | END | |
12732 | ||
12733 | <STATIC> | |
12734 | ||
12735 | import from TempA all; | |
12736 | ||
12737 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12738 | ||
12739 | ||
12740 | <TTCN_TC:EXEC> | |
12741 | ||
12742 | if (dec_BER_PDU('A0040A810103'O) == myValue) | |
12743 | ||
12744 | {setverdict(pass);} else {setverdict(fail);} | |
12745 | ||
12746 | ||
12747 | <RESULT> | |
12748 | ||
12749 | Overall verdict: pass | |
12750 | ||
12751 | <END_TC> | |
12752 | ||
12753 | :exmp. | |
12754 | ||
12755 | .*---------------------------------------------------------------------* | |
12756 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (fourth) | |
12757 | .*---------------------------------------------------------------------* | |
12758 | :xmp tab=0. | |
12759 | ||
12760 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (fourth)> | |
12761 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12762 | ||
12763 | <STATIC:ASN> | |
12764 | ||
12765 | TempA | |
12766 | ||
12767 | DEFINITIONS ::= | |
12768 | BEGIN | |
12769 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12770 | ||
12771 | ||
12772 | myValue BERPDU ::= fourth | |
12773 | ||
12774 | ||
12775 | ||
12776 | END | |
12777 | ||
12778 | <STATIC> | |
12779 | ||
12780 | import from TempA all; | |
12781 | ||
12782 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12783 | ||
12784 | ||
12785 | <TTCN_TC:EXEC> | |
12786 | ||
12787 | if (dec_BER_PDU('A081040A810103'O) == myValue) | |
12788 | ||
12789 | {setverdict(pass);} else {setverdict(fail);} | |
12790 | ||
12791 | ||
12792 | <RESULT> | |
12793 | ||
12794 | Overall verdict: pass | |
12795 | ||
12796 | <END_TC> | |
12797 | ||
12798 | :exmp. | |
12799 | ||
12800 | .*---------------------------------------------------------------------* | |
12801 | :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (fourth) | |
12802 | .*---------------------------------------------------------------------* | |
12803 | :xmp tab=0. | |
12804 | ||
12805 | <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (fourth)> | |
12806 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12807 | ||
12808 | <STATIC:ASN> | |
12809 | ||
12810 | TempA | |
12811 | ||
12812 | DEFINITIONS ::= | |
12813 | BEGIN | |
12814 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12815 | ||
12816 | ||
12817 | myValue BERPDU ::= fourth | |
12818 | ||
12819 | ||
12820 | ||
12821 | END | |
12822 | ||
12823 | <STATIC> | |
12824 | ||
12825 | import from TempA all; | |
12826 | ||
12827 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12828 | ||
12829 | ||
12830 | <TTCN_TC:EXEC> | |
12831 | ||
12832 | if (dec_BER_PDU('9F580103'O) == myValue) | |
12833 | ||
12834 | {setverdict(pass);} else {setverdict(fail);} | |
12835 | ||
12836 | ||
12837 | <RESULT> | |
12838 | ||
12839 | Overall verdict: pass | |
12840 | ||
12841 | <END_TC> | |
12842 | ||
12843 | :exmp. | |
12844 | ||
12845 | .*---------------------------------------------------------------------* | |
12846 | :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (fourth) | |
12847 | .*---------------------------------------------------------------------* | |
12848 | :xmp tab=0. | |
12849 | ||
12850 | <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (fourth)> | |
12851 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12852 | ||
12853 | <STATIC:ASN> | |
12854 | ||
12855 | TempA | |
12856 | ||
12857 | DEFINITIONS ::= | |
12858 | BEGIN | |
12859 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12860 | ||
12861 | ||
12862 | myValue BERPDU ::= fourth | |
12863 | ||
12864 | ||
12865 | ||
12866 | END | |
12867 | ||
12868 | <STATIC> | |
12869 | ||
12870 | import from TempA all; | |
12871 | ||
12872 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12873 | ||
12874 | ||
12875 | <TTCN_TC:EXEC> | |
12876 | ||
12877 | if (dec_BER_PDU('9F58810103'O) == myValue) | |
12878 | ||
12879 | {setverdict(pass);} else {setverdict(fail);} | |
12880 | ||
12881 | ||
12882 | <RESULT> | |
12883 | ||
12884 | Overall verdict: pass | |
12885 | ||
12886 | <END_TC> | |
12887 | ||
12888 | :exmp. | |
12889 | ||
12890 | .*---------------------------------------------------------------------* | |
12891 | :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (fifth(5)) | |
12892 | .*---------------------------------------------------------------------* | |
12893 | :xmp tab=0. | |
12894 | ||
12895 | <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (fifth(5))> | |
12896 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12897 | ||
12898 | <STATIC:ASN> | |
12899 | ||
12900 | TempA | |
12901 | ||
12902 | DEFINITIONS ::= | |
12903 | BEGIN | |
12904 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12905 | ||
12906 | ||
12907 | myValue BERPDU ::= fifth | |
12908 | ||
12909 | ||
12910 | ||
12911 | END | |
12912 | ||
12913 | <STATIC> | |
12914 | ||
12915 | import from TempA all; | |
12916 | ||
12917 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12918 | ||
12919 | ||
12920 | <TTCN_TC:EXEC> | |
12921 | ||
12922 | if (dec_BER_PDU('0A0105'O) == myValue) | |
12923 | ||
12924 | {setverdict(pass);} else {setverdict(fail);} | |
12925 | ||
12926 | ||
12927 | <RESULT> | |
12928 | ||
12929 | Overall verdict: pass | |
12930 | ||
12931 | <END_TC> | |
12932 | ||
12933 | :exmp. | |
12934 | ||
12935 | .*---------------------------------------------------------------------* | |
12936 | :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (fifth(5)) | |
12937 | .*---------------------------------------------------------------------* | |
12938 | :xmp tab=0. | |
12939 | ||
12940 | <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (fifth(5))> | |
12941 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12942 | ||
12943 | <STATIC:ASN> | |
12944 | ||
12945 | TempA | |
12946 | ||
12947 | DEFINITIONS ::= | |
12948 | BEGIN | |
12949 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12950 | ||
12951 | ||
12952 | myValue BERPDU ::= fifth | |
12953 | ||
12954 | ||
12955 | ||
12956 | END | |
12957 | ||
12958 | <STATIC> | |
12959 | ||
12960 | import from TempA all; | |
12961 | ||
12962 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
12963 | ||
12964 | ||
12965 | <TTCN_TC:EXEC> | |
12966 | ||
12967 | if (dec_BER_PDU('0A810105'O) == myValue) | |
12968 | ||
12969 | {setverdict(pass);} else {setverdict(fail);} | |
12970 | ||
12971 | ||
12972 | <RESULT> | |
12973 | ||
12974 | Overall verdict: pass | |
12975 | ||
12976 | <END_TC> | |
12977 | ||
12978 | :exmp. | |
12979 | ||
12980 | .*---------------------------------------------------------------------* | |
12981 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (fifth(5)) | |
12982 | .*---------------------------------------------------------------------* | |
12983 | :xmp tab=0. | |
12984 | ||
12985 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (fifth(5))> | |
12986 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12987 | ||
12988 | <STATIC:ASN> | |
12989 | ||
12990 | TempA | |
12991 | ||
12992 | DEFINITIONS ::= | |
12993 | BEGIN | |
12994 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
12995 | ||
12996 | ||
12997 | myValue BERPDU ::= fifth | |
12998 | ||
12999 | ||
13000 | ||
13001 | END | |
13002 | ||
13003 | <STATIC> | |
13004 | ||
13005 | import from TempA all; | |
13006 | ||
13007 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
13008 | ||
13009 | ||
13010 | <TTCN_TC:EXEC> | |
13011 | ||
13012 | if (dec_BER_PDU('A0030A0105'O) == myValue) | |
13013 | ||
13014 | {setverdict(pass);} else {setverdict(fail);} | |
13015 | ||
13016 | ||
13017 | <RESULT> | |
13018 | ||
13019 | Overall verdict: pass | |
13020 | ||
13021 | <END_TC> | |
13022 | ||
13023 | :exmp. | |
13024 | ||
13025 | .*---------------------------------------------------------------------* | |
13026 | :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (fifth(5)) | |
13027 | .*---------------------------------------------------------------------* | |
13028 | :xmp tab=0. | |
13029 | ||
13030 | <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (fifth(5))> | |
13031 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13032 | ||
13033 | <STATIC:ASN> | |
13034 | ||
13035 | TempA | |
13036 | ||
13037 | DEFINITIONS ::= | |
13038 | BEGIN | |
13039 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13040 | ||
13041 | ||
13042 | myValue BERPDU ::= fifth | |
13043 | ||
13044 | ||
13045 | ||
13046 | END | |
13047 | ||
13048 | <STATIC> | |
13049 | ||
13050 | import from TempA all; | |
13051 | ||
13052 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
13053 | ||
13054 | ||
13055 | <TTCN_TC:EXEC> | |
13056 | ||
13057 | if (dec_BER_PDU('A0800A01050000'O) == myValue) | |
13058 | ||
13059 | {setverdict(pass);} else {setverdict(fail);} | |
13060 | ||
13061 | ||
13062 | <RESULT> | |
13063 | ||
13064 | Overall verdict: pass | |
13065 | ||
13066 | <END_TC> | |
13067 | ||
13068 | :exmp. | |
13069 | ||
13070 | .*---------------------------------------------------------------------* | |
13071 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (fifth(5)) | |
13072 | .*---------------------------------------------------------------------* | |
13073 | :xmp tab=0. | |
13074 | ||
13075 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (fifth(5))> | |
13076 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13077 | ||
13078 | <STATIC:ASN> | |
13079 | ||
13080 | TempA | |
13081 | ||
13082 | DEFINITIONS ::= | |
13083 | BEGIN | |
13084 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13085 | ||
13086 | ||
13087 | myValue BERPDU ::= fifth | |
13088 | ||
13089 | ||
13090 | ||
13091 | END | |
13092 | ||
13093 | <STATIC> | |
13094 | ||
13095 | import from TempA all; | |
13096 | ||
13097 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
13098 | ||
13099 | ||
13100 | <TTCN_TC:EXEC> | |
13101 | ||
13102 | if (dec_BER_PDU('A0040A810105'O) == myValue) | |
13103 | ||
13104 | {setverdict(pass);} else {setverdict(fail);} | |
13105 | ||
13106 | ||
13107 | <RESULT> | |
13108 | ||
13109 | Overall verdict: pass | |
13110 | ||
13111 | <END_TC> | |
13112 | ||
13113 | :exmp. | |
13114 | ||
13115 | .*---------------------------------------------------------------------* | |
13116 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (fifth(5)) | |
13117 | .*---------------------------------------------------------------------* | |
13118 | :xmp tab=0. | |
13119 | ||
13120 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (fifth(5))> | |
13121 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13122 | ||
13123 | <STATIC:ASN> | |
13124 | ||
13125 | TempA | |
13126 | ||
13127 | DEFINITIONS ::= | |
13128 | BEGIN | |
13129 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13130 | ||
13131 | ||
13132 | myValue BERPDU ::= fifth | |
13133 | ||
13134 | ||
13135 | ||
13136 | END | |
13137 | ||
13138 | <STATIC> | |
13139 | ||
13140 | import from TempA all; | |
13141 | ||
13142 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
13143 | ||
13144 | ||
13145 | <TTCN_TC:EXEC> | |
13146 | ||
13147 | if (dec_BER_PDU('A081040A810105'O) == myValue) | |
13148 | ||
13149 | {setverdict(pass);} else {setverdict(fail);} | |
13150 | ||
13151 | ||
13152 | <RESULT> | |
13153 | ||
13154 | Overall verdict: pass | |
13155 | ||
13156 | <END_TC> | |
13157 | ||
13158 | :exmp. | |
13159 | ||
13160 | .*---------------------------------------------------------------------* | |
13161 | :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (fifth(5)) | |
13162 | .*---------------------------------------------------------------------* | |
13163 | :xmp tab=0. | |
13164 | ||
13165 | <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (fifth(5))> | |
13166 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13167 | ||
13168 | <STATIC:ASN> | |
13169 | ||
13170 | TempA | |
13171 | ||
13172 | DEFINITIONS ::= | |
13173 | BEGIN | |
13174 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13175 | ||
13176 | ||
13177 | myValue BERPDU ::= fifth | |
13178 | ||
13179 | ||
13180 | ||
13181 | END | |
13182 | ||
13183 | <STATIC> | |
13184 | ||
13185 | import from TempA all; | |
13186 | ||
13187 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
13188 | ||
13189 | ||
13190 | <TTCN_TC:EXEC> | |
13191 | ||
13192 | if (dec_BER_PDU('9F580105'O) == myValue) | |
13193 | ||
13194 | {setverdict(pass);} else {setverdict(fail);} | |
13195 | ||
13196 | ||
13197 | <RESULT> | |
13198 | ||
13199 | Overall verdict: pass | |
13200 | ||
13201 | <END_TC> | |
13202 | ||
13203 | :exmp. | |
13204 | ||
13205 | .*---------------------------------------------------------------------* | |
13206 | :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (fifth(5)) | |
13207 | .*---------------------------------------------------------------------* | |
13208 | :xmp tab=0. | |
13209 | ||
13210 | <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (fifth(5))> | |
13211 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13212 | ||
13213 | <STATIC:ASN> | |
13214 | ||
13215 | TempA | |
13216 | ||
13217 | DEFINITIONS ::= | |
13218 | BEGIN | |
13219 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13220 | ||
13221 | ||
13222 | myValue BERPDU ::= fifth | |
13223 | ||
13224 | ||
13225 | ||
13226 | END | |
13227 | ||
13228 | <STATIC> | |
13229 | ||
13230 | import from TempA all; | |
13231 | ||
13232 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
13233 | ||
13234 | ||
13235 | <TTCN_TC:EXEC> | |
13236 | ||
13237 | if (dec_BER_PDU('9F58810105'O) == myValue) | |
13238 | ||
13239 | {setverdict(pass);} else {setverdict(fail);} | |
13240 | ||
13241 | ||
13242 | <RESULT> | |
13243 | ||
13244 | Overall verdict: pass | |
13245 | ||
13246 | <END_TC> | |
13247 | ||
13248 | :exmp. | |
13249 | ||
13250 | .*---------------------------------------------------------------------* | |
13251 | :h3. DECODING OF UNTAGGED ENUMERATED, CER+DER (sixth) | |
13252 | .*---------------------------------------------------------------------* | |
13253 | :xmp tab=0. | |
13254 | ||
13255 | <TC - DECODING OF UNTAGGED ENUMERATED, CER+DER (sixth)> | |
13256 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13257 | ||
13258 | <STATIC:ASN> | |
13259 | ||
13260 | TempA | |
13261 | ||
13262 | DEFINITIONS ::= | |
13263 | BEGIN | |
13264 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13265 | ||
13266 | ||
13267 | myValue BERPDU ::= sixth | |
13268 | ||
13269 | ||
13270 | ||
13271 | END | |
13272 | ||
13273 | <STATIC> | |
13274 | ||
13275 | import from TempA all; | |
13276 | ||
13277 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
13278 | ||
13279 | ||
13280 | <TTCN_TC:EXEC> | |
13281 | ||
13282 | if (dec_BER_PDU('0A0106'O) == myValue) | |
13283 | ||
13284 | {setverdict(pass);} else {setverdict(fail);} | |
13285 | ||
13286 | ||
13287 | <RESULT> | |
13288 | ||
13289 | Overall verdict: pass | |
13290 | ||
13291 | <END_TC> | |
13292 | ||
13293 | :exmp. | |
13294 | ||
13295 | .*---------------------------------------------------------------------* | |
13296 | :h3. DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (sixth) | |
13297 | .*---------------------------------------------------------------------* | |
13298 | :xmp tab=0. | |
13299 | ||
13300 | <TC - DECODING OF UNTAGGED ENUMERATED, Length of length = 1, (sixth)> | |
13301 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13302 | ||
13303 | <STATIC:ASN> | |
13304 | ||
13305 | TempA | |
13306 | ||
13307 | DEFINITIONS ::= | |
13308 | BEGIN | |
13309 | BERPDU ::= ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13310 | ||
13311 | ||
13312 | myValue BERPDU ::= sixth | |
13313 | ||
13314 | ||
13315 | ||
13316 | END | |
13317 | ||
13318 | <STATIC> | |
13319 | ||
13320 | import from TempA all; | |
13321 | ||
13322 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
13323 | ||
13324 | ||
13325 | <TTCN_TC:EXEC> | |
13326 | ||
13327 | if (dec_BER_PDU('0A810106'O) == myValue) | |
13328 | ||
13329 | {setverdict(pass);} else {setverdict(fail);} | |
13330 | ||
13331 | ||
13332 | <RESULT> | |
13333 | ||
13334 | Overall verdict: pass | |
13335 | ||
13336 | <END_TC> | |
13337 | ||
13338 | :exmp. | |
13339 | ||
13340 | .*---------------------------------------------------------------------* | |
13341 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (sixth) | |
13342 | .*---------------------------------------------------------------------* | |
13343 | :xmp tab=0. | |
13344 | ||
13345 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, DER (short form - short form) (sixth)> | |
13346 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13347 | ||
13348 | <STATIC:ASN> | |
13349 | ||
13350 | TempA | |
13351 | ||
13352 | DEFINITIONS ::= | |
13353 | BEGIN | |
13354 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13355 | ||
13356 | ||
13357 | myValue BERPDU ::= sixth | |
13358 | ||
13359 | ||
13360 | ||
13361 | END | |
13362 | ||
13363 | <STATIC> | |
13364 | ||
13365 | import from TempA all; | |
13366 | ||
13367 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
13368 | ||
13369 | ||
13370 | <TTCN_TC:EXEC> | |
13371 | ||
13372 | if (dec_BER_PDU('A0030A0106'O) == myValue) | |
13373 | ||
13374 | {setverdict(pass);} else {setverdict(fail);} | |
13375 | ||
13376 | ||
13377 | <RESULT> | |
13378 | ||
13379 | Overall verdict: pass | |
13380 | ||
13381 | <END_TC> | |
13382 | ||
13383 | :exmp. | |
13384 | ||
13385 | .*---------------------------------------------------------------------* | |
13386 | :h3. DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (sixth) | |
13387 | .*---------------------------------------------------------------------* | |
13388 | :xmp tab=0. | |
13389 | ||
13390 | <TC - DECODING OF EXPLICIT TAGGED OF ENUMERATED, CER (INDEFINITE FORM) (sixth)> | |
13391 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13392 | ||
13393 | <STATIC:ASN> | |
13394 | ||
13395 | TempA | |
13396 | ||
13397 | DEFINITIONS ::= | |
13398 | BEGIN | |
13399 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13400 | ||
13401 | ||
13402 | myValue BERPDU ::= sixth | |
13403 | ||
13404 | ||
13405 | ||
13406 | END | |
13407 | ||
13408 | <STATIC> | |
13409 | ||
13410 | import from TempA all; | |
13411 | ||
13412 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
13413 | ||
13414 | ||
13415 | <TTCN_TC:EXEC> | |
13416 | ||
13417 | if (dec_BER_PDU('A0800A01060000'O) == myValue) | |
13418 | ||
13419 | {setverdict(pass);} else {setverdict(fail);} | |
13420 | ||
13421 | ||
13422 | <RESULT> | |
13423 | ||
13424 | Overall verdict: pass | |
13425 | ||
13426 | <END_TC> | |
13427 | ||
13428 | :exmp. | |
13429 | ||
13430 | .*---------------------------------------------------------------------* | |
13431 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (sixth) | |
13432 | .*---------------------------------------------------------------------* | |
13433 | :xmp tab=0. | |
13434 | ||
13435 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, short form - long form (sixth)> | |
13436 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13437 | ||
13438 | <STATIC:ASN> | |
13439 | ||
13440 | TempA | |
13441 | ||
13442 | DEFINITIONS ::= | |
13443 | BEGIN | |
13444 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13445 | ||
13446 | ||
13447 | myValue BERPDU ::= sixth | |
13448 | ||
13449 | ||
13450 | ||
13451 | END | |
13452 | ||
13453 | <STATIC> | |
13454 | ||
13455 | import from TempA all; | |
13456 | ||
13457 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
13458 | ||
13459 | ||
13460 | <TTCN_TC:EXEC> | |
13461 | ||
13462 | if (dec_BER_PDU('A0040A810106'O) == myValue) | |
13463 | ||
13464 | {setverdict(pass);} else {setverdict(fail);} | |
13465 | ||
13466 | ||
13467 | <RESULT> | |
13468 | ||
13469 | Overall verdict: pass | |
13470 | ||
13471 | <END_TC> | |
13472 | ||
13473 | :exmp. | |
13474 | ||
13475 | .*---------------------------------------------------------------------* | |
13476 | :h3. DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (sixth) | |
13477 | .*---------------------------------------------------------------------* | |
13478 | :xmp tab=0. | |
13479 | ||
13480 | <TC - DECODING OF EXPLICIT TAGGED ENUMERATED, long form - long form (sixth)> | |
13481 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13482 | ||
13483 | <STATIC:ASN> | |
13484 | ||
13485 | TempA | |
13486 | ||
13487 | DEFINITIONS ::= | |
13488 | BEGIN | |
13489 | BERPDU ::= [0] EXPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13490 | ||
13491 | ||
13492 | myValue BERPDU ::= sixth | |
13493 | ||
13494 | ||
13495 | ||
13496 | END | |
13497 | ||
13498 | <STATIC> | |
13499 | ||
13500 | import from TempA all; | |
13501 | ||
13502 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
13503 | ||
13504 | ||
13505 | <TTCN_TC:EXEC> | |
13506 | ||
13507 | if (dec_BER_PDU('A081040A810106'O) == myValue) | |
13508 | ||
13509 | {setverdict(pass);} else {setverdict(fail);} | |
13510 | ||
13511 | ||
13512 | <RESULT> | |
13513 | ||
13514 | Overall verdict: pass | |
13515 | ||
13516 | <END_TC> | |
13517 | ||
13518 | :exmp. | |
13519 | ||
13520 | .*---------------------------------------------------------------------* | |
13521 | :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (sixth) | |
13522 | .*---------------------------------------------------------------------* | |
13523 | :xmp tab=0. | |
13524 | ||
13525 | <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, CER+DER (sixth)> | |
13526 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13527 | ||
13528 | <STATIC:ASN> | |
13529 | ||
13530 | TempA | |
13531 | ||
13532 | DEFINITIONS ::= | |
13533 | BEGIN | |
13534 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13535 | ||
13536 | ||
13537 | myValue BERPDU ::= sixth | |
13538 | ||
13539 | ||
13540 | ||
13541 | END | |
13542 | ||
13543 | <STATIC> | |
13544 | ||
13545 | import from TempA all; | |
13546 | ||
13547 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
13548 | ||
13549 | ||
13550 | <TTCN_TC:EXEC> | |
13551 | ||
13552 | if (dec_BER_PDU('9F580106'O) == myValue) | |
13553 | ||
13554 | {setverdict(pass);} else {setverdict(fail);} | |
13555 | ||
13556 | ||
13557 | <RESULT> | |
13558 | ||
13559 | Overall verdict: pass | |
13560 | ||
13561 | <END_TC> | |
13562 | ||
13563 | :exmp. | |
13564 | ||
13565 | .*---------------------------------------------------------------------* | |
13566 | :h3. DECODING OF IMPLICIT TAGGED ENUMERATED, long form (sixth) | |
13567 | .*---------------------------------------------------------------------* | |
13568 | :xmp tab=0. | |
13569 | ||
13570 | <TC - DECODING OF IMPLICIT TAGGED ENUMERATED, long form (sixth)> | |
13571 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13572 | ||
13573 | <STATIC:ASN> | |
13574 | ||
13575 | TempA | |
13576 | ||
13577 | DEFINITIONS ::= | |
13578 | BEGIN | |
13579 | BERPDU ::= [88] IMPLICIT ENUMERATED {first, second(0),third,...,fourth, fifth(5),sixth} | |
13580 | ||
13581 | ||
13582 | myValue BERPDU ::= sixth | |
13583 | ||
13584 | ||
13585 | ||
13586 | END | |
13587 | ||
13588 | <STATIC> | |
13589 | ||
13590 | import from TempA all; | |
13591 | ||
13592 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
13593 | ||
13594 | ||
13595 | <TTCN_TC:EXEC> | |
13596 | ||
13597 | if (dec_BER_PDU('9F58810106'O) == myValue) | |
13598 | ||
13599 | {setverdict(pass);} else {setverdict(fail);} | |
13600 | ||
13601 | ||
13602 | <RESULT> | |
13603 | ||
13604 | Overall verdict: pass | |
13605 | ||
13606 | <END_TC> | |
13607 | ||
13608 | :exmp. | |
13609 | ||
13610 | .*---------------------------------------------------------------------* | |
13611 | :h3.CER + DER encoding of REAL, 0 (primitive) | |
13612 | .*---------------------------------------------------------------------* | |
13613 | :xmp tab=0. | |
13614 | ||
13615 | <TC - CER + DER encoding of REAL, 0 (primitive)> | |
13616 | ||
13617 | <STATIC:ASN> | |
13618 | ||
13619 | TempA | |
13620 | ||
13621 | DEFINITIONS ::= | |
13622 | BEGIN | |
13623 | BERPDU ::= REAL | |
13624 | b BERPDU ::= 0 | |
13625 | ||
13626 | END | |
13627 | ||
13628 | <STATIC> | |
13629 | ||
13630 | import from TempA all; | |
13631 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
13632 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
13633 | ||
13634 | ||
13635 | ||
13636 | <TTCN_TC:EXEC> | |
13637 | ||
13638 | if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);} | |
13639 | ||
13640 | <RESULT> | |
13641 | ||
13642 | Overall verdict: pass | |
13643 | ||
13644 | <END_TC> | |
13645 | ||
13646 | :exmp. | |
13647 | ||
13648 | .*---------------------------------------------------------------------* | |
13649 | :h3.CER + DER encoding of REAL, 0.0 (primitive) | |
13650 | .*---------------------------------------------------------------------* | |
13651 | :xmp tab=0. | |
13652 | ||
13653 | <TC - CER + DER encoding of REAL, 0.0 (primitive)> | |
13654 | ||
13655 | <STATIC:ASN> | |
13656 | ||
13657 | TempA | |
13658 | ||
13659 | DEFINITIONS ::= | |
13660 | BEGIN | |
13661 | BERPDU ::= REAL | |
13662 | b BERPDU ::= 0.0 | |
13663 | ||
13664 | END | |
13665 | ||
13666 | <STATIC> | |
13667 | ||
13668 | import from TempA all; | |
13669 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
13670 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
13671 | ||
13672 | ||
13673 | ||
13674 | <TTCN_TC:EXEC> | |
13675 | ||
13676 | if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);} | |
13677 | ||
13678 | <RESULT> | |
13679 | ||
13680 | Overall verdict: pass | |
13681 | ||
13682 | <END_TC> | |
13683 | ||
13684 | :exmp. | |
13685 | ||
13686 | .*---------------------------------------------------------------------* | |
13687 | :h3.CER + DER encoding of REAL, 0E0 (primitive) | |
13688 | .*---------------------------------------------------------------------* | |
13689 | :xmp tab=0. | |
13690 | ||
13691 | <TC - CER + DER encoding of REAL, 0E0 (primitive)> | |
13692 | ||
13693 | <STATIC:ASN> | |
13694 | ||
13695 | TempA | |
13696 | ||
13697 | DEFINITIONS ::= | |
13698 | BEGIN | |
13699 | BERPDU ::= REAL | |
13700 | b BERPDU ::= 0E0 | |
13701 | ||
13702 | END | |
13703 | ||
13704 | <STATIC> | |
13705 | ||
13706 | import from TempA all; | |
13707 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
13708 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
13709 | ||
13710 | ||
13711 | ||
13712 | <TTCN_TC:EXEC> | |
13713 | ||
13714 | if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);} | |
13715 | ||
13716 | <RESULT> | |
13717 | ||
13718 | Overall verdict: pass | |
13719 | ||
13720 | <END_TC> | |
13721 | ||
13722 | :exmp. | |
13723 | ||
13724 | .*---------------------------------------------------------------------* | |
13725 | :h3.CER + DER encoding of REAL, 0.0E0 (primitive) | |
13726 | .*---------------------------------------------------------------------* | |
13727 | :xmp tab=0. | |
13728 | ||
13729 | <TC - CER + DER encoding of REAL, 0.0E0 (primitive)> | |
13730 | ||
13731 | <STATIC:ASN> | |
13732 | ||
13733 | TempA | |
13734 | ||
13735 | DEFINITIONS ::= | |
13736 | BEGIN | |
13737 | BERPDU ::= REAL | |
13738 | b BERPDU ::= 0.0E0 | |
13739 | ||
13740 | END | |
13741 | ||
13742 | <STATIC> | |
13743 | ||
13744 | import from TempA all; | |
13745 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
13746 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
13747 | ||
13748 | ||
13749 | ||
13750 | <TTCN_TC:EXEC> | |
13751 | ||
13752 | if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);} | |
13753 | ||
13754 | <RESULT> | |
13755 | ||
13756 | Overall verdict: pass | |
13757 | ||
13758 | <END_TC> | |
13759 | ||
13760 | :exmp. | |
13761 | ||
13762 | .*---------------------------------------------------------------------* | |
13763 | :h3.CER + DER encoding of REAL, 0e0 (primitive) | |
13764 | .*---------------------------------------------------------------------* | |
13765 | :xmp tab=0. | |
13766 | ||
13767 | <TC - CER + DER encoding of REAL, 0e0 (primitive)> | |
13768 | ||
13769 | <STATIC:ASN> | |
13770 | ||
13771 | TempA | |
13772 | ||
13773 | DEFINITIONS ::= | |
13774 | BEGIN | |
13775 | BERPDU ::= REAL | |
13776 | b BERPDU ::= 0e0 | |
13777 | ||
13778 | END | |
13779 | ||
13780 | <STATIC> | |
13781 | ||
13782 | import from TempA all; | |
13783 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
13784 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
13785 | ||
13786 | ||
13787 | ||
13788 | <TTCN_TC:EXEC> | |
13789 | ||
13790 | if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);} | |
13791 | ||
13792 | <RESULT> | |
13793 | ||
13794 | Overall verdict: pass | |
13795 | ||
13796 | <END_TC> | |
13797 | ||
13798 | :exmp. | |
13799 | ||
13800 | .*---------------------------------------------------------------------* | |
13801 | :h3.CER + DER encoding of REAL, 0.0e0 (primitive) | |
13802 | .*---------------------------------------------------------------------* | |
13803 | :xmp tab=0. | |
13804 | ||
13805 | <TC - CER + DER encoding of REAL, 0.0e0 (primitive)> | |
13806 | ||
13807 | <STATIC:ASN> | |
13808 | ||
13809 | TempA | |
13810 | ||
13811 | DEFINITIONS ::= | |
13812 | BEGIN | |
13813 | BERPDU ::= REAL | |
13814 | b BERPDU ::= 0.0e0 | |
13815 | ||
13816 | END | |
13817 | ||
13818 | <STATIC> | |
13819 | ||
13820 | import from TempA all; | |
13821 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
13822 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
13823 | ||
13824 | ||
13825 | ||
13826 | <TTCN_TC:EXEC> | |
13827 | ||
13828 | if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);} | |
13829 | ||
13830 | <RESULT> | |
13831 | ||
13832 | Overall verdict: pass | |
13833 | ||
13834 | <END_TC> | |
13835 | ||
13836 | :exmp. | |
13837 | ||
13838 | .*---------------------------------------------------------------------* | |
13839 | :h3.CER + DER encoding of REAL, 0E+0 (primitive) | |
13840 | .*---------------------------------------------------------------------* | |
13841 | :xmp tab=0. | |
13842 | ||
13843 | <TC - CER + DER encoding of REAL, 0E+0 (primitive)> | |
13844 | ||
13845 | <STATIC:ASN> | |
13846 | ||
13847 | TempA | |
13848 | ||
13849 | DEFINITIONS ::= | |
13850 | BEGIN | |
13851 | BERPDU ::= REAL | |
13852 | b BERPDU ::= 0E+0 | |
13853 | ||
13854 | END | |
13855 | ||
13856 | <STATIC> | |
13857 | ||
13858 | import from TempA all; | |
13859 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
13860 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
13861 | ||
13862 | ||
13863 | ||
13864 | <TTCN_TC:EXEC> | |
13865 | ||
13866 | if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);} | |
13867 | ||
13868 | <RESULT> | |
13869 | ||
13870 | Overall verdict: pass | |
13871 | ||
13872 | <END_TC> | |
13873 | ||
13874 | :exmp. | |
13875 | ||
13876 | .*---------------------------------------------------------------------* | |
13877 | :h3.CER + DER encoding of REAL, 0.0E+0 (primitive) | |
13878 | .*---------------------------------------------------------------------* | |
13879 | :xmp tab=0. | |
13880 | ||
13881 | <TC - CER + DER encoding of REAL, 0.0E+0 (primitive)> | |
13882 | ||
13883 | <STATIC:ASN> | |
13884 | ||
13885 | TempA | |
13886 | ||
13887 | DEFINITIONS ::= | |
13888 | BEGIN | |
13889 | BERPDU ::= REAL | |
13890 | b BERPDU ::= 0.0E+0 | |
13891 | ||
13892 | END | |
13893 | ||
13894 | <STATIC> | |
13895 | ||
13896 | import from TempA all; | |
13897 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
13898 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
13899 | ||
13900 | ||
13901 | ||
13902 | <TTCN_TC:EXEC> | |
13903 | ||
13904 | if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);} | |
13905 | ||
13906 | <RESULT> | |
13907 | ||
13908 | Overall verdict: pass | |
13909 | ||
13910 | <END_TC> | |
13911 | ||
13912 | :exmp. | |
13913 | ||
13914 | .*---------------------------------------------------------------------* | |
13915 | :h3.CER + DER encoding of REAL, 0e+0 (primitive) | |
13916 | .*---------------------------------------------------------------------* | |
13917 | :xmp tab=0. | |
13918 | ||
13919 | <TC - CER + DER encoding of REAL, 0e+0 (primitive)> | |
13920 | ||
13921 | <STATIC:ASN> | |
13922 | ||
13923 | TempA | |
13924 | ||
13925 | DEFINITIONS ::= | |
13926 | BEGIN | |
13927 | BERPDU ::= REAL | |
13928 | b BERPDU ::= 0e+0 | |
13929 | ||
13930 | END | |
13931 | ||
13932 | <STATIC> | |
13933 | ||
13934 | import from TempA all; | |
13935 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
13936 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
13937 | ||
13938 | ||
13939 | ||
13940 | <TTCN_TC:EXEC> | |
13941 | ||
13942 | if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);} | |
13943 | ||
13944 | <RESULT> | |
13945 | ||
13946 | Overall verdict: pass | |
13947 | ||
13948 | <END_TC> | |
13949 | ||
13950 | :exmp. | |
13951 | ||
13952 | .*---------------------------------------------------------------------* | |
13953 | :h3.CER + DER encoding of REAL, 0.0e+0 (primitive) | |
13954 | .*---------------------------------------------------------------------* | |
13955 | :xmp tab=0. | |
13956 | ||
13957 | <TC - CER + DER encoding of REAL, 0.0e+0 (primitive)> | |
13958 | ||
13959 | <STATIC:ASN> | |
13960 | ||
13961 | TempA | |
13962 | ||
13963 | DEFINITIONS ::= | |
13964 | BEGIN | |
13965 | BERPDU ::= REAL | |
13966 | b BERPDU ::= 0.0e+0 | |
13967 | ||
13968 | END | |
13969 | ||
13970 | <STATIC> | |
13971 | ||
13972 | import from TempA all; | |
13973 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
13974 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
13975 | ||
13976 | ||
13977 | ||
13978 | <TTCN_TC:EXEC> | |
13979 | ||
13980 | if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);} | |
13981 | ||
13982 | <RESULT> | |
13983 | ||
13984 | Overall verdict: pass | |
13985 | ||
13986 | <END_TC> | |
13987 | ||
13988 | :exmp. | |
13989 | ||
13990 | .*---------------------------------------------------------------------* | |
13991 | :h3.CER + DER encoding of REAL, 0E-0 (primitive) | |
13992 | .*---------------------------------------------------------------------* | |
13993 | :xmp tab=0. | |
13994 | ||
13995 | <TC - CER + DER encoding of REAL, 0E-0 (primitive)> | |
13996 | ||
13997 | <STATIC:ASN> | |
13998 | ||
13999 | TempA | |
14000 | ||
14001 | DEFINITIONS ::= | |
14002 | BEGIN | |
14003 | BERPDU ::= REAL | |
14004 | b BERPDU ::= 0E-0 | |
14005 | ||
14006 | END | |
14007 | ||
14008 | <STATIC> | |
14009 | ||
14010 | import from TempA all; | |
14011 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14012 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14013 | ||
14014 | ||
14015 | ||
14016 | <TTCN_TC:EXEC> | |
14017 | ||
14018 | if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);} | |
14019 | ||
14020 | <RESULT> | |
14021 | ||
14022 | Overall verdict: pass | |
14023 | ||
14024 | <END_TC> | |
14025 | ||
14026 | :exmp. | |
14027 | ||
14028 | .*---------------------------------------------------------------------* | |
14029 | :h3.CER + DER encoding of REAL, 0.0E-0 (primitive) | |
14030 | .*---------------------------------------------------------------------* | |
14031 | :xmp tab=0. | |
14032 | ||
14033 | <TC - CER + DER encoding of REAL, 0.0E-0 (primitive)> | |
14034 | ||
14035 | <STATIC:ASN> | |
14036 | ||
14037 | TempA | |
14038 | ||
14039 | DEFINITIONS ::= | |
14040 | BEGIN | |
14041 | BERPDU ::= REAL | |
14042 | b BERPDU ::= 0.0E-0 | |
14043 | ||
14044 | END | |
14045 | ||
14046 | <STATIC> | |
14047 | ||
14048 | import from TempA all; | |
14049 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14050 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14051 | ||
14052 | ||
14053 | ||
14054 | <TTCN_TC:EXEC> | |
14055 | ||
14056 | if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);} | |
14057 | ||
14058 | <RESULT> | |
14059 | ||
14060 | Overall verdict: pass | |
14061 | ||
14062 | <END_TC> | |
14063 | ||
14064 | :exmp. | |
14065 | ||
14066 | .*---------------------------------------------------------------------* | |
14067 | :h3.CER + DER encoding of REAL, 0e-0 (primitive) | |
14068 | .*---------------------------------------------------------------------* | |
14069 | :xmp tab=0. | |
14070 | ||
14071 | <TC - CER + DER encoding of REAL, 0e-0 (primitive)> | |
14072 | ||
14073 | <STATIC:ASN> | |
14074 | ||
14075 | TempA | |
14076 | ||
14077 | DEFINITIONS ::= | |
14078 | BEGIN | |
14079 | BERPDU ::= REAL | |
14080 | b BERPDU ::= 0e-0 | |
14081 | ||
14082 | END | |
14083 | ||
14084 | <STATIC> | |
14085 | ||
14086 | import from TempA all; | |
14087 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14088 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14089 | ||
14090 | ||
14091 | ||
14092 | <TTCN_TC:EXEC> | |
14093 | ||
14094 | if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);} | |
14095 | ||
14096 | <RESULT> | |
14097 | ||
14098 | Overall verdict: pass | |
14099 | ||
14100 | <END_TC> | |
14101 | ||
14102 | :exmp. | |
14103 | ||
14104 | .*---------------------------------------------------------------------* | |
14105 | :h3.CER + DER encoding of REAL, 0.0e-0 (primitive) | |
14106 | .*---------------------------------------------------------------------* | |
14107 | :xmp tab=0. | |
14108 | ||
14109 | <TC - CER + DER encoding of REAL, 0.0e-0 (primitive)> | |
14110 | ||
14111 | <STATIC:ASN> | |
14112 | ||
14113 | TempA | |
14114 | ||
14115 | DEFINITIONS ::= | |
14116 | BEGIN | |
14117 | BERPDU ::= REAL | |
14118 | b BERPDU ::= 0.0e-0 | |
14119 | ||
14120 | END | |
14121 | ||
14122 | <STATIC> | |
14123 | ||
14124 | import from TempA all; | |
14125 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14126 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14127 | ||
14128 | ||
14129 | ||
14130 | <TTCN_TC:EXEC> | |
14131 | ||
14132 | if ((enc_DER_PDU(b) == '0900'O)and(enc_CER_PDU(b) == '0900'O)) {setverdict(pass);} else {setverdict(fail);} | |
14133 | ||
14134 | <RESULT> | |
14135 | ||
14136 | Overall verdict: pass | |
14137 | ||
14138 | <END_TC> | |
14139 | ||
14140 | :exmp. | |
14141 | ||
14142 | .*---------------------------------------------------------------------* | |
14143 | :h3.CER + DER encoding of REAL, 1 (primitive) | |
14144 | .*---------------------------------------------------------------------* | |
14145 | :xmp tab=0. | |
14146 | ||
14147 | <TC - CER + DER encoding of REAL, 1 (primitive)> | |
14148 | ||
14149 | <STATIC:ASN> | |
14150 | ||
14151 | TempA | |
14152 | ||
14153 | DEFINITIONS ::= | |
14154 | BEGIN | |
14155 | BERPDU ::= REAL | |
14156 | b BERPDU ::= 1 | |
14157 | ||
14158 | END | |
14159 | ||
14160 | <STATIC> | |
14161 | ||
14162 | import from TempA all; | |
14163 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14164 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14165 | ||
14166 | ||
14167 | ||
14168 | <TTCN_TC:EXEC> | |
14169 | ||
14170 | if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14171 | ||
14172 | <RESULT> | |
14173 | ||
14174 | Overall verdict: pass | |
14175 | ||
14176 | <END_TC> | |
14177 | ||
14178 | :exmp. | |
14179 | ||
14180 | .*---------------------------------------------------------------------* | |
14181 | :h3.CER + DER encoding of REAL, 1e0 (primitive) | |
14182 | .*---------------------------------------------------------------------* | |
14183 | :xmp tab=0. | |
14184 | ||
14185 | <TC - CER + DER encoding of REAL, 1e0 (primitive)> | |
14186 | ||
14187 | <STATIC:ASN> | |
14188 | ||
14189 | TempA | |
14190 | ||
14191 | DEFINITIONS ::= | |
14192 | BEGIN | |
14193 | BERPDU ::= REAL | |
14194 | b BERPDU ::= 1e0 | |
14195 | ||
14196 | END | |
14197 | ||
14198 | <STATIC> | |
14199 | ||
14200 | import from TempA all; | |
14201 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14202 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14203 | ||
14204 | ||
14205 | ||
14206 | <TTCN_TC:EXEC> | |
14207 | ||
14208 | if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14209 | ||
14210 | <RESULT> | |
14211 | ||
14212 | Overall verdict: pass | |
14213 | ||
14214 | <END_TC> | |
14215 | ||
14216 | :exmp. | |
14217 | ||
14218 | .*---------------------------------------------------------------------* | |
14219 | :h3.CER + DER encoding of REAL, 1E0 (primitive) | |
14220 | .*---------------------------------------------------------------------* | |
14221 | :xmp tab=0. | |
14222 | ||
14223 | <TC - CER + DER encoding of REAL, 1E0 (primitive)> | |
14224 | ||
14225 | <STATIC:ASN> | |
14226 | ||
14227 | TempA | |
14228 | ||
14229 | DEFINITIONS ::= | |
14230 | BEGIN | |
14231 | BERPDU ::= REAL | |
14232 | b BERPDU ::= 1E0 | |
14233 | ||
14234 | END | |
14235 | ||
14236 | <STATIC> | |
14237 | ||
14238 | import from TempA all; | |
14239 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14240 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14241 | ||
14242 | ||
14243 | ||
14244 | <TTCN_TC:EXEC> | |
14245 | ||
14246 | if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14247 | ||
14248 | <RESULT> | |
14249 | ||
14250 | Overall verdict: pass | |
14251 | ||
14252 | <END_TC> | |
14253 | ||
14254 | :exmp. | |
14255 | ||
14256 | .*---------------------------------------------------------------------* | |
14257 | :h3.CER + DER encoding of REAL, 1.0e0 (primitive) | |
14258 | .*---------------------------------------------------------------------* | |
14259 | :xmp tab=0. | |
14260 | ||
14261 | <TC - CER + DER encoding of REAL, 1.0e0 (primitive)> | |
14262 | ||
14263 | <STATIC:ASN> | |
14264 | ||
14265 | TempA | |
14266 | ||
14267 | DEFINITIONS ::= | |
14268 | BEGIN | |
14269 | BERPDU ::= REAL | |
14270 | b BERPDU ::= 1.0e0 | |
14271 | ||
14272 | END | |
14273 | ||
14274 | <STATIC> | |
14275 | ||
14276 | import from TempA all; | |
14277 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14278 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14279 | ||
14280 | ||
14281 | ||
14282 | <TTCN_TC:EXEC> | |
14283 | ||
14284 | if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14285 | ||
14286 | <RESULT> | |
14287 | ||
14288 | Overall verdict: pass | |
14289 | ||
14290 | <END_TC> | |
14291 | ||
14292 | :exmp. | |
14293 | ||
14294 | .*---------------------------------------------------------------------* | |
14295 | :h3.CER + DER encoding of REAL, 1.0E0 (primitive) | |
14296 | .*---------------------------------------------------------------------* | |
14297 | :xmp tab=0. | |
14298 | ||
14299 | <TC - CER + DER encoding of REAL, 1.0E0 (primitive)> | |
14300 | ||
14301 | <STATIC:ASN> | |
14302 | ||
14303 | TempA | |
14304 | ||
14305 | DEFINITIONS ::= | |
14306 | BEGIN | |
14307 | BERPDU ::= REAL | |
14308 | b BERPDU ::= 1.0E0 | |
14309 | ||
14310 | END | |
14311 | ||
14312 | <STATIC> | |
14313 | ||
14314 | import from TempA all; | |
14315 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14316 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14317 | ||
14318 | ||
14319 | ||
14320 | <TTCN_TC:EXEC> | |
14321 | ||
14322 | if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14323 | ||
14324 | <RESULT> | |
14325 | ||
14326 | Overall verdict: pass | |
14327 | ||
14328 | <END_TC> | |
14329 | ||
14330 | :exmp. | |
14331 | ||
14332 | .*---------------------------------------------------------------------* | |
14333 | :h3.CER + DER encoding of REAL, 1e+0 (primitive) | |
14334 | .*---------------------------------------------------------------------* | |
14335 | :xmp tab=0. | |
14336 | ||
14337 | <TC - CER + DER encoding of REAL, 1e+0 (primitive)> | |
14338 | ||
14339 | <STATIC:ASN> | |
14340 | ||
14341 | TempA | |
14342 | ||
14343 | DEFINITIONS ::= | |
14344 | BEGIN | |
14345 | BERPDU ::= REAL | |
14346 | b BERPDU ::= 1e+0 | |
14347 | ||
14348 | END | |
14349 | ||
14350 | <STATIC> | |
14351 | ||
14352 | import from TempA all; | |
14353 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14354 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14355 | ||
14356 | ||
14357 | ||
14358 | <TTCN_TC:EXEC> | |
14359 | ||
14360 | if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14361 | ||
14362 | <RESULT> | |
14363 | ||
14364 | Overall verdict: pass | |
14365 | ||
14366 | <END_TC> | |
14367 | ||
14368 | :exmp. | |
14369 | ||
14370 | .*---------------------------------------------------------------------* | |
14371 | :h3.CER + DER encoding of REAL, 1E+0 (primitive) | |
14372 | .*---------------------------------------------------------------------* | |
14373 | :xmp tab=0. | |
14374 | ||
14375 | <TC - CER + DER encoding of REAL, 1E+0 (primitive)> | |
14376 | ||
14377 | <STATIC:ASN> | |
14378 | ||
14379 | TempA | |
14380 | ||
14381 | DEFINITIONS ::= | |
14382 | BEGIN | |
14383 | BERPDU ::= REAL | |
14384 | b BERPDU ::= 1E+0 | |
14385 | ||
14386 | END | |
14387 | ||
14388 | <STATIC> | |
14389 | ||
14390 | import from TempA all; | |
14391 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14392 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14393 | ||
14394 | ||
14395 | ||
14396 | <TTCN_TC:EXEC> | |
14397 | ||
14398 | if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14399 | ||
14400 | <RESULT> | |
14401 | ||
14402 | Overall verdict: pass | |
14403 | ||
14404 | <END_TC> | |
14405 | ||
14406 | :exmp. | |
14407 | ||
14408 | .*---------------------------------------------------------------------* | |
14409 | :h3.CER + DER encoding of REAL, 1.0e+0 (primitive) | |
14410 | .*---------------------------------------------------------------------* | |
14411 | :xmp tab=0. | |
14412 | ||
14413 | <TC - CER + DER encoding of REAL, 1.0e+0 (primitive)> | |
14414 | ||
14415 | <STATIC:ASN> | |
14416 | ||
14417 | TempA | |
14418 | ||
14419 | DEFINITIONS ::= | |
14420 | BEGIN | |
14421 | BERPDU ::= REAL | |
14422 | b BERPDU ::= 1.0e+0 | |
14423 | ||
14424 | END | |
14425 | ||
14426 | <STATIC> | |
14427 | ||
14428 | import from TempA all; | |
14429 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14430 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14431 | ||
14432 | ||
14433 | ||
14434 | <TTCN_TC:EXEC> | |
14435 | ||
14436 | if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14437 | ||
14438 | <RESULT> | |
14439 | ||
14440 | Overall verdict: pass | |
14441 | ||
14442 | <END_TC> | |
14443 | ||
14444 | :exmp. | |
14445 | ||
14446 | .*---------------------------------------------------------------------* | |
14447 | :h3.CER + DER encoding of REAL, 1.0E+0 (primitive) | |
14448 | .*---------------------------------------------------------------------* | |
14449 | :xmp tab=0. | |
14450 | ||
14451 | <TC - CER + DER encoding of REAL, 1.0E+0 (primitive)> | |
14452 | ||
14453 | <STATIC:ASN> | |
14454 | ||
14455 | TempA | |
14456 | ||
14457 | DEFINITIONS ::= | |
14458 | BEGIN | |
14459 | BERPDU ::= REAL | |
14460 | b BERPDU ::= 1.0E+0 | |
14461 | ||
14462 | END | |
14463 | ||
14464 | <STATIC> | |
14465 | ||
14466 | import from TempA all; | |
14467 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14468 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14469 | ||
14470 | ||
14471 | ||
14472 | <TTCN_TC:EXEC> | |
14473 | ||
14474 | if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14475 | ||
14476 | <RESULT> | |
14477 | ||
14478 | Overall verdict: pass | |
14479 | ||
14480 | <END_TC> | |
14481 | ||
14482 | :exmp. | |
14483 | ||
14484 | .*---------------------------------------------------------------------* | |
14485 | :h3.CER + DER encoding of REAL, 1e-0 (primitive) | |
14486 | .*---------------------------------------------------------------------* | |
14487 | :xmp tab=0. | |
14488 | ||
14489 | <TC - CER + DER encoding of REAL, 1e-0 (primitive)> | |
14490 | ||
14491 | <STATIC:ASN> | |
14492 | ||
14493 | TempA | |
14494 | ||
14495 | DEFINITIONS ::= | |
14496 | BEGIN | |
14497 | BERPDU ::= REAL | |
14498 | b BERPDU ::= 1e-0 | |
14499 | ||
14500 | END | |
14501 | ||
14502 | <STATIC> | |
14503 | ||
14504 | import from TempA all; | |
14505 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14506 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14507 | ||
14508 | ||
14509 | ||
14510 | <TTCN_TC:EXEC> | |
14511 | ||
14512 | if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14513 | ||
14514 | <RESULT> | |
14515 | ||
14516 | Overall verdict: pass | |
14517 | ||
14518 | <END_TC> | |
14519 | ||
14520 | :exmp. | |
14521 | ||
14522 | .*---------------------------------------------------------------------* | |
14523 | :h3.CER + DER encoding of REAL, 1E-0 (primitive) | |
14524 | .*---------------------------------------------------------------------* | |
14525 | :xmp tab=0. | |
14526 | ||
14527 | <TC - CER + DER encoding of REAL, 1E-0 (primitive)> | |
14528 | ||
14529 | <STATIC:ASN> | |
14530 | ||
14531 | TempA | |
14532 | ||
14533 | DEFINITIONS ::= | |
14534 | BEGIN | |
14535 | BERPDU ::= REAL | |
14536 | b BERPDU ::= 1E-0 | |
14537 | ||
14538 | END | |
14539 | ||
14540 | <STATIC> | |
14541 | ||
14542 | import from TempA all; | |
14543 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14544 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14545 | ||
14546 | ||
14547 | ||
14548 | <TTCN_TC:EXEC> | |
14549 | ||
14550 | if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14551 | ||
14552 | <RESULT> | |
14553 | ||
14554 | Overall verdict: pass | |
14555 | ||
14556 | <END_TC> | |
14557 | ||
14558 | :exmp. | |
14559 | ||
14560 | .*---------------------------------------------------------------------* | |
14561 | :h3.CER + DER encoding of REAL, 1.0e-0 (primitive) | |
14562 | .*---------------------------------------------------------------------* | |
14563 | :xmp tab=0. | |
14564 | ||
14565 | <TC - CER + DER encoding of REAL, 1.0e-0 (primitive)> | |
14566 | ||
14567 | <STATIC:ASN> | |
14568 | ||
14569 | TempA | |
14570 | ||
14571 | DEFINITIONS ::= | |
14572 | BEGIN | |
14573 | BERPDU ::= REAL | |
14574 | b BERPDU ::= 1.0e-0 | |
14575 | ||
14576 | END | |
14577 | ||
14578 | <STATIC> | |
14579 | ||
14580 | import from TempA all; | |
14581 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14582 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14583 | ||
14584 | ||
14585 | ||
14586 | <TTCN_TC:EXEC> | |
14587 | ||
14588 | if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14589 | ||
14590 | <RESULT> | |
14591 | ||
14592 | Overall verdict: pass | |
14593 | ||
14594 | <END_TC> | |
14595 | ||
14596 | :exmp. | |
14597 | ||
14598 | .*---------------------------------------------------------------------* | |
14599 | :h3.CER + DER encoding of REAL, 1.0E-0 (primitive) | |
14600 | .*---------------------------------------------------------------------* | |
14601 | :xmp tab=0. | |
14602 | ||
14603 | <TC - CER + DER encoding of REAL, 1.0E-0 (primitive)> | |
14604 | ||
14605 | <STATIC:ASN> | |
14606 | ||
14607 | TempA | |
14608 | ||
14609 | DEFINITIONS ::= | |
14610 | BEGIN | |
14611 | BERPDU ::= REAL | |
14612 | b BERPDU ::= 1.0E-0 | |
14613 | ||
14614 | END | |
14615 | ||
14616 | <STATIC> | |
14617 | ||
14618 | import from TempA all; | |
14619 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14620 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14621 | ||
14622 | ||
14623 | ||
14624 | <TTCN_TC:EXEC> | |
14625 | ||
14626 | if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14627 | ||
14628 | <RESULT> | |
14629 | ||
14630 | Overall verdict: pass | |
14631 | ||
14632 | <END_TC> | |
14633 | ||
14634 | :exmp. | |
14635 | ||
14636 | .*---------------------------------------------------------------------* | |
14637 | :h3.CER + DER encoding of REAL, 2 (primitive) | |
14638 | .*---------------------------------------------------------------------* | |
14639 | :xmp tab=0. | |
14640 | ||
14641 | <TC - CER + DER encoding of REAL, 2 (primitive)> | |
14642 | ||
14643 | <STATIC:ASN> | |
14644 | ||
14645 | TempA | |
14646 | ||
14647 | DEFINITIONS ::= | |
14648 | BEGIN | |
14649 | BERPDU ::= REAL | |
14650 | b BERPDU ::= 2 | |
14651 | ||
14652 | END | |
14653 | ||
14654 | <STATIC> | |
14655 | ||
14656 | import from TempA all; | |
14657 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14658 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14659 | ||
14660 | ||
14661 | ||
14662 | <TTCN_TC:EXEC> | |
14663 | ||
14664 | if ((enc_DER_PDU(b) == '090603322E452B30'O)and(enc_CER_PDU(b) == '090603322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14665 | ||
14666 | <RESULT> | |
14667 | ||
14668 | Overall verdict: pass | |
14669 | ||
14670 | <END_TC> | |
14671 | ||
14672 | :exmp. | |
14673 | ||
14674 | .*---------------------------------------------------------------------* | |
14675 | :h3.CER + DER encoding of REAL, 2.0 (primitive) | |
14676 | .*---------------------------------------------------------------------* | |
14677 | :xmp tab=0. | |
14678 | ||
14679 | <TC - CER + DER encoding of REAL, 2.0 (primitive)> | |
14680 | ||
14681 | <STATIC:ASN> | |
14682 | ||
14683 | TempA | |
14684 | ||
14685 | DEFINITIONS ::= | |
14686 | BEGIN | |
14687 | BERPDU ::= REAL | |
14688 | b BERPDU ::= 2.0 | |
14689 | ||
14690 | END | |
14691 | ||
14692 | <STATIC> | |
14693 | ||
14694 | import from TempA all; | |
14695 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14696 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14697 | ||
14698 | ||
14699 | ||
14700 | <TTCN_TC:EXEC> | |
14701 | ||
14702 | if ((enc_DER_PDU(b) == '090603322E452B30'O)and(enc_CER_PDU(b) == '090603322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14703 | ||
14704 | <RESULT> | |
14705 | ||
14706 | Overall verdict: pass | |
14707 | ||
14708 | <END_TC> | |
14709 | ||
14710 | :exmp. | |
14711 | ||
14712 | .*---------------------------------------------------------------------* | |
14713 | :h3.CER + DER encoding of REAL, -1 (primitive) | |
14714 | .*---------------------------------------------------------------------* | |
14715 | :xmp tab=0. | |
14716 | ||
14717 | <TC - CER + DER encoding of REAL, -1 (primitive)> | |
14718 | ||
14719 | <STATIC:ASN> | |
14720 | ||
14721 | TempA | |
14722 | ||
14723 | DEFINITIONS ::= | |
14724 | BEGIN | |
14725 | BERPDU ::= REAL | |
14726 | b BERPDU ::= -1 | |
14727 | ||
14728 | END | |
14729 | ||
14730 | <STATIC> | |
14731 | ||
14732 | import from TempA all; | |
14733 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14734 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14735 | ||
14736 | ||
14737 | ||
14738 | <TTCN_TC:EXEC> | |
14739 | ||
14740 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14741 | ||
14742 | <RESULT> | |
14743 | ||
14744 | Overall verdict: pass | |
14745 | ||
14746 | <END_TC> | |
14747 | ||
14748 | :exmp. | |
14749 | ||
14750 | .*---------------------------------------------------------------------* | |
14751 | :h3.CER + DER encoding of REAL, -1e0 (primitive) | |
14752 | .*---------------------------------------------------------------------* | |
14753 | :xmp tab=0. | |
14754 | ||
14755 | <TC - CER + DER encoding of REAL, -1e0 (primitive)> | |
14756 | ||
14757 | <STATIC:ASN> | |
14758 | ||
14759 | TempA | |
14760 | ||
14761 | DEFINITIONS ::= | |
14762 | BEGIN | |
14763 | BERPDU ::= REAL | |
14764 | b BERPDU ::= -1e0 | |
14765 | ||
14766 | END | |
14767 | ||
14768 | <STATIC> | |
14769 | ||
14770 | import from TempA all; | |
14771 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14772 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14773 | ||
14774 | ||
14775 | ||
14776 | <TTCN_TC:EXEC> | |
14777 | ||
14778 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14779 | ||
14780 | <RESULT> | |
14781 | ||
14782 | Overall verdict: pass | |
14783 | ||
14784 | <END_TC> | |
14785 | ||
14786 | :exmp. | |
14787 | ||
14788 | .*---------------------------------------------------------------------* | |
14789 | :h3.CER + DER encoding of REAL, -1E0 (primitive) | |
14790 | .*---------------------------------------------------------------------* | |
14791 | :xmp tab=0. | |
14792 | ||
14793 | <TC - CER + DER encoding of REAL, -1E0 (primitive)> | |
14794 | ||
14795 | <STATIC:ASN> | |
14796 | ||
14797 | TempA | |
14798 | ||
14799 | DEFINITIONS ::= | |
14800 | BEGIN | |
14801 | BERPDU ::= REAL | |
14802 | b BERPDU ::= -1E0 | |
14803 | ||
14804 | END | |
14805 | ||
14806 | <STATIC> | |
14807 | ||
14808 | import from TempA all; | |
14809 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14810 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14811 | ||
14812 | ||
14813 | ||
14814 | <TTCN_TC:EXEC> | |
14815 | ||
14816 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14817 | ||
14818 | <RESULT> | |
14819 | ||
14820 | Overall verdict: pass | |
14821 | ||
14822 | <END_TC> | |
14823 | ||
14824 | :exmp. | |
14825 | ||
14826 | .*---------------------------------------------------------------------* | |
14827 | :h3.CER + DER encoding of REAL, -1.0e0 (primitive) | |
14828 | .*---------------------------------------------------------------------* | |
14829 | :xmp tab=0. | |
14830 | ||
14831 | <TC - CER + DER encoding of REAL, -1.0e0 (primitive)> | |
14832 | ||
14833 | <STATIC:ASN> | |
14834 | ||
14835 | TempA | |
14836 | ||
14837 | DEFINITIONS ::= | |
14838 | BEGIN | |
14839 | BERPDU ::= REAL | |
14840 | b BERPDU ::= -1.0e0 | |
14841 | ||
14842 | END | |
14843 | ||
14844 | <STATIC> | |
14845 | ||
14846 | import from TempA all; | |
14847 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14848 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14849 | ||
14850 | ||
14851 | ||
14852 | <TTCN_TC:EXEC> | |
14853 | ||
14854 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14855 | ||
14856 | <RESULT> | |
14857 | ||
14858 | Overall verdict: pass | |
14859 | ||
14860 | <END_TC> | |
14861 | ||
14862 | :exmp. | |
14863 | ||
14864 | .*---------------------------------------------------------------------* | |
14865 | :h3.CER + DER encoding of REAL, -1.0E0 (primitive) | |
14866 | .*---------------------------------------------------------------------* | |
14867 | :xmp tab=0. | |
14868 | ||
14869 | <TC - CER + DER encoding of REAL, -1.0E0 (primitive)> | |
14870 | ||
14871 | <STATIC:ASN> | |
14872 | ||
14873 | TempA | |
14874 | ||
14875 | DEFINITIONS ::= | |
14876 | BEGIN | |
14877 | BERPDU ::= REAL | |
14878 | b BERPDU ::= -1.0E0 | |
14879 | ||
14880 | END | |
14881 | ||
14882 | <STATIC> | |
14883 | ||
14884 | import from TempA all; | |
14885 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14886 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14887 | ||
14888 | ||
14889 | ||
14890 | <TTCN_TC:EXEC> | |
14891 | ||
14892 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14893 | ||
14894 | <RESULT> | |
14895 | ||
14896 | Overall verdict: pass | |
14897 | ||
14898 | <END_TC> | |
14899 | ||
14900 | :exmp. | |
14901 | ||
14902 | .*---------------------------------------------------------------------* | |
14903 | :h3.CER + DER encoding of REAL, -1e+0 (primitive) | |
14904 | .*---------------------------------------------------------------------* | |
14905 | :xmp tab=0. | |
14906 | ||
14907 | <TC - CER + DER encoding of REAL, -1e+0 (primitive)> | |
14908 | ||
14909 | <STATIC:ASN> | |
14910 | ||
14911 | TempA | |
14912 | ||
14913 | DEFINITIONS ::= | |
14914 | BEGIN | |
14915 | BERPDU ::= REAL | |
14916 | b BERPDU ::= -1e+0 | |
14917 | ||
14918 | END | |
14919 | ||
14920 | <STATIC> | |
14921 | ||
14922 | import from TempA all; | |
14923 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14924 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14925 | ||
14926 | ||
14927 | ||
14928 | <TTCN_TC:EXEC> | |
14929 | ||
14930 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14931 | ||
14932 | <RESULT> | |
14933 | ||
14934 | Overall verdict: pass | |
14935 | ||
14936 | <END_TC> | |
14937 | ||
14938 | :exmp. | |
14939 | ||
14940 | .*---------------------------------------------------------------------* | |
14941 | :h3.CER + DER encoding of REAL, -1E+0 (primitive) | |
14942 | .*---------------------------------------------------------------------* | |
14943 | :xmp tab=0. | |
14944 | ||
14945 | <TC - CER + DER encoding of REAL, -1E+0 (primitive)> | |
14946 | ||
14947 | <STATIC:ASN> | |
14948 | ||
14949 | TempA | |
14950 | ||
14951 | DEFINITIONS ::= | |
14952 | BEGIN | |
14953 | BERPDU ::= REAL | |
14954 | b BERPDU ::= -1E+0 | |
14955 | ||
14956 | END | |
14957 | ||
14958 | <STATIC> | |
14959 | ||
14960 | import from TempA all; | |
14961 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
14962 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
14963 | ||
14964 | ||
14965 | ||
14966 | <TTCN_TC:EXEC> | |
14967 | ||
14968 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
14969 | ||
14970 | <RESULT> | |
14971 | ||
14972 | Overall verdict: pass | |
14973 | ||
14974 | <END_TC> | |
14975 | ||
14976 | :exmp. | |
14977 | ||
14978 | .*---------------------------------------------------------------------* | |
14979 | :h3.CER + DER encoding of REAL, -1.0e+0 (primitive) | |
14980 | .*---------------------------------------------------------------------* | |
14981 | :xmp tab=0. | |
14982 | ||
14983 | <TC - CER + DER encoding of REAL, -1.0e+0 (primitive)> | |
14984 | ||
14985 | <STATIC:ASN> | |
14986 | ||
14987 | TempA | |
14988 | ||
14989 | DEFINITIONS ::= | |
14990 | BEGIN | |
14991 | BERPDU ::= REAL | |
14992 | b BERPDU ::= -1.0e+0 | |
14993 | ||
14994 | END | |
14995 | ||
14996 | <STATIC> | |
14997 | ||
14998 | import from TempA all; | |
14999 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15000 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15001 | ||
15002 | ||
15003 | ||
15004 | <TTCN_TC:EXEC> | |
15005 | ||
15006 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15007 | ||
15008 | <RESULT> | |
15009 | ||
15010 | Overall verdict: pass | |
15011 | ||
15012 | <END_TC> | |
15013 | ||
15014 | :exmp. | |
15015 | ||
15016 | .*---------------------------------------------------------------------* | |
15017 | :h3.CER + DER encoding of REAL, -1.0E+0 (primitive) | |
15018 | .*---------------------------------------------------------------------* | |
15019 | :xmp tab=0. | |
15020 | ||
15021 | <TC - CER + DER encoding of REAL, -1.0E+0 (primitive)> | |
15022 | ||
15023 | <STATIC:ASN> | |
15024 | ||
15025 | TempA | |
15026 | ||
15027 | DEFINITIONS ::= | |
15028 | BEGIN | |
15029 | BERPDU ::= REAL | |
15030 | b BERPDU ::= -1.0E+0 | |
15031 | ||
15032 | END | |
15033 | ||
15034 | <STATIC> | |
15035 | ||
15036 | import from TempA all; | |
15037 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15038 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15039 | ||
15040 | ||
15041 | ||
15042 | <TTCN_TC:EXEC> | |
15043 | ||
15044 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15045 | ||
15046 | <RESULT> | |
15047 | ||
15048 | Overall verdict: pass | |
15049 | ||
15050 | <END_TC> | |
15051 | ||
15052 | :exmp. | |
15053 | ||
15054 | .*---------------------------------------------------------------------* | |
15055 | :h3.CER + DER encoding of REAL, -1e-0 (primitive) | |
15056 | .*---------------------------------------------------------------------* | |
15057 | :xmp tab=0. | |
15058 | ||
15059 | <TC - CER + DER encoding of REAL, -1e-0 (primitive)> | |
15060 | ||
15061 | <STATIC:ASN> | |
15062 | ||
15063 | TempA | |
15064 | ||
15065 | DEFINITIONS ::= | |
15066 | BEGIN | |
15067 | BERPDU ::= REAL | |
15068 | b BERPDU ::= -1e-0 | |
15069 | ||
15070 | END | |
15071 | ||
15072 | <STATIC> | |
15073 | ||
15074 | import from TempA all; | |
15075 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15076 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15077 | ||
15078 | ||
15079 | ||
15080 | <TTCN_TC:EXEC> | |
15081 | ||
15082 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15083 | ||
15084 | <RESULT> | |
15085 | ||
15086 | Overall verdict: pass | |
15087 | ||
15088 | <END_TC> | |
15089 | ||
15090 | :exmp. | |
15091 | ||
15092 | .*---------------------------------------------------------------------* | |
15093 | :h3.CER + DER encoding of REAL, -1E-0 (primitive) | |
15094 | .*---------------------------------------------------------------------* | |
15095 | :xmp tab=0. | |
15096 | ||
15097 | <TC - CER + DER encoding of REAL, -1E-0 (primitive)> | |
15098 | ||
15099 | <STATIC:ASN> | |
15100 | ||
15101 | TempA | |
15102 | ||
15103 | DEFINITIONS ::= | |
15104 | BEGIN | |
15105 | BERPDU ::= REAL | |
15106 | b BERPDU ::= -1E-0 | |
15107 | ||
15108 | END | |
15109 | ||
15110 | <STATIC> | |
15111 | ||
15112 | import from TempA all; | |
15113 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15114 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15115 | ||
15116 | ||
15117 | ||
15118 | <TTCN_TC:EXEC> | |
15119 | ||
15120 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15121 | ||
15122 | <RESULT> | |
15123 | ||
15124 | Overall verdict: pass | |
15125 | ||
15126 | <END_TC> | |
15127 | ||
15128 | :exmp. | |
15129 | ||
15130 | .*---------------------------------------------------------------------* | |
15131 | :h3.CER + DER encoding of REAL, -1.0e-0 (primitive) | |
15132 | .*---------------------------------------------------------------------* | |
15133 | :xmp tab=0. | |
15134 | ||
15135 | <TC - CER + DER encoding of REAL, -1.0e-0 (primitive)> | |
15136 | ||
15137 | <STATIC:ASN> | |
15138 | ||
15139 | TempA | |
15140 | ||
15141 | DEFINITIONS ::= | |
15142 | BEGIN | |
15143 | BERPDU ::= REAL | |
15144 | b BERPDU ::= -1.0e-0 | |
15145 | ||
15146 | END | |
15147 | ||
15148 | <STATIC> | |
15149 | ||
15150 | import from TempA all; | |
15151 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15152 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15153 | ||
15154 | ||
15155 | ||
15156 | <TTCN_TC:EXEC> | |
15157 | ||
15158 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15159 | ||
15160 | <RESULT> | |
15161 | ||
15162 | Overall verdict: pass | |
15163 | ||
15164 | <END_TC> | |
15165 | ||
15166 | :exmp. | |
15167 | ||
15168 | .*---------------------------------------------------------------------* | |
15169 | :h3.CER + DER encoding of REAL, -1.0E-0 (primitive) | |
15170 | .*---------------------------------------------------------------------* | |
15171 | :xmp tab=0. | |
15172 | ||
15173 | <TC - CER + DER encoding of REAL, -1.0E-0 (primitive)> | |
15174 | ||
15175 | <STATIC:ASN> | |
15176 | ||
15177 | TempA | |
15178 | ||
15179 | DEFINITIONS ::= | |
15180 | BEGIN | |
15181 | BERPDU ::= REAL | |
15182 | b BERPDU ::= -1.0E-0 | |
15183 | ||
15184 | END | |
15185 | ||
15186 | <STATIC> | |
15187 | ||
15188 | import from TempA all; | |
15189 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15190 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15191 | ||
15192 | ||
15193 | ||
15194 | <TTCN_TC:EXEC> | |
15195 | ||
15196 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15197 | ||
15198 | <RESULT> | |
15199 | ||
15200 | Overall verdict: pass | |
15201 | ||
15202 | <END_TC> | |
15203 | ||
15204 | :exmp. | |
15205 | ||
15206 | .*---------------------------------------------------------------------* | |
15207 | :h3.CER + DER encoding of REAL, -1.0 (primitive) | |
15208 | .*---------------------------------------------------------------------* | |
15209 | :xmp tab=0. | |
15210 | ||
15211 | <TC - CER + DER encoding of REAL, -1.0 (primitive)> | |
15212 | ||
15213 | <STATIC:ASN> | |
15214 | ||
15215 | TempA | |
15216 | ||
15217 | DEFINITIONS ::= | |
15218 | BEGIN | |
15219 | BERPDU ::= REAL | |
15220 | b BERPDU ::= -1.0 | |
15221 | ||
15222 | END | |
15223 | ||
15224 | <STATIC> | |
15225 | ||
15226 | import from TempA all; | |
15227 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15228 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15229 | ||
15230 | ||
15231 | ||
15232 | <TTCN_TC:EXEC> | |
15233 | ||
15234 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15235 | ||
15236 | <RESULT> | |
15237 | ||
15238 | Overall verdict: pass | |
15239 | ||
15240 | <END_TC> | |
15241 | ||
15242 | :exmp. | |
15243 | ||
15244 | .*---------------------------------------------------------------------* | |
15245 | :h3.CER + DER encoding of REAL, 1.000 (primitive) | |
15246 | .*---------------------------------------------------------------------* | |
15247 | :xmp tab=0. | |
15248 | ||
15249 | <TC - CER + DER encoding of REAL, 1.000 (primitive)> | |
15250 | ||
15251 | <STATIC:ASN> | |
15252 | ||
15253 | TempA | |
15254 | ||
15255 | DEFINITIONS ::= | |
15256 | BEGIN | |
15257 | BERPDU ::= REAL | |
15258 | b BERPDU ::= 1.000 | |
15259 | ||
15260 | END | |
15261 | ||
15262 | <STATIC> | |
15263 | ||
15264 | import from TempA all; | |
15265 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15266 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15267 | ||
15268 | ||
15269 | ||
15270 | <TTCN_TC:EXEC> | |
15271 | ||
15272 | if ((enc_DER_PDU(b) == '090603312E452B30'O)and(enc_CER_PDU(b) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15273 | ||
15274 | <RESULT> | |
15275 | ||
15276 | Overall verdict: pass | |
15277 | ||
15278 | <END_TC> | |
15279 | ||
15280 | :exmp. | |
15281 | ||
15282 | .*---------------------------------------------------------------------* | |
15283 | :h3.CER + DER encoding of REAL, -1.000 (primitive) | |
15284 | .*---------------------------------------------------------------------* | |
15285 | :xmp tab=0. | |
15286 | ||
15287 | <TC - CER + DER encoding of REAL, -1.000 (primitive)> | |
15288 | ||
15289 | <STATIC:ASN> | |
15290 | ||
15291 | TempA | |
15292 | ||
15293 | DEFINITIONS ::= | |
15294 | BEGIN | |
15295 | BERPDU ::= REAL | |
15296 | b BERPDU ::= -1.000 | |
15297 | ||
15298 | END | |
15299 | ||
15300 | <STATIC> | |
15301 | ||
15302 | import from TempA all; | |
15303 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15304 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15305 | ||
15306 | ||
15307 | ||
15308 | <TTCN_TC:EXEC> | |
15309 | ||
15310 | if ((enc_DER_PDU(b) == '0907032D312E452B30'O)and(enc_CER_PDU(b) == '0907032D312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15311 | ||
15312 | <RESULT> | |
15313 | ||
15314 | Overall verdict: pass | |
15315 | ||
15316 | <END_TC> | |
15317 | ||
15318 | :exmp. | |
15319 | ||
15320 | .*---------------------------------------------------------------------* | |
15321 | :h3.CER + DER encoding of REAL, 12 (primitive) | |
15322 | .*---------------------------------------------------------------------* | |
15323 | :xmp tab=0. | |
15324 | ||
15325 | <TC - CER + DER encoding of REAL, 12 (primitive)> | |
15326 | ||
15327 | <STATIC:ASN> | |
15328 | ||
15329 | TempA | |
15330 | ||
15331 | DEFINITIONS ::= | |
15332 | BEGIN | |
15333 | BERPDU ::= REAL | |
15334 | b BERPDU ::= 12 | |
15335 | ||
15336 | END | |
15337 | ||
15338 | <STATIC> | |
15339 | ||
15340 | import from TempA all; | |
15341 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15342 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15343 | ||
15344 | ||
15345 | ||
15346 | <TTCN_TC:EXEC> | |
15347 | ||
15348 | if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15349 | ||
15350 | <RESULT> | |
15351 | ||
15352 | Overall verdict: pass | |
15353 | ||
15354 | <END_TC> | |
15355 | ||
15356 | :exmp. | |
15357 | ||
15358 | .*---------------------------------------------------------------------* | |
15359 | :h3.CER + DER encoding of REAL, 12.0 (primitive) | |
15360 | .*---------------------------------------------------------------------* | |
15361 | :xmp tab=0. | |
15362 | ||
15363 | <TC - CER + DER encoding of REAL, 12.0 (primitive)> | |
15364 | ||
15365 | <STATIC:ASN> | |
15366 | ||
15367 | TempA | |
15368 | ||
15369 | DEFINITIONS ::= | |
15370 | BEGIN | |
15371 | BERPDU ::= REAL | |
15372 | b BERPDU ::= 12.0 | |
15373 | ||
15374 | END | |
15375 | ||
15376 | <STATIC> | |
15377 | ||
15378 | import from TempA all; | |
15379 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15380 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15381 | ||
15382 | ||
15383 | ||
15384 | <TTCN_TC:EXEC> | |
15385 | ||
15386 | if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15387 | ||
15388 | <RESULT> | |
15389 | ||
15390 | Overall verdict: pass | |
15391 | ||
15392 | <END_TC> | |
15393 | ||
15394 | :exmp. | |
15395 | ||
15396 | .*---------------------------------------------------------------------* | |
15397 | :h3.CER + DER encoding of REAL, 12.0E0 (primitive) | |
15398 | .*---------------------------------------------------------------------* | |
15399 | :xmp tab=0. | |
15400 | ||
15401 | <TC - CER + DER encoding of REAL, 12.0E0 (primitive)> | |
15402 | ||
15403 | <STATIC:ASN> | |
15404 | ||
15405 | TempA | |
15406 | ||
15407 | DEFINITIONS ::= | |
15408 | BEGIN | |
15409 | BERPDU ::= REAL | |
15410 | b BERPDU ::= 12.0E0 | |
15411 | ||
15412 | END | |
15413 | ||
15414 | <STATIC> | |
15415 | ||
15416 | import from TempA all; | |
15417 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15418 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15419 | ||
15420 | ||
15421 | ||
15422 | <TTCN_TC:EXEC> | |
15423 | ||
15424 | if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15425 | ||
15426 | <RESULT> | |
15427 | ||
15428 | Overall verdict: pass | |
15429 | ||
15430 | <END_TC> | |
15431 | ||
15432 | :exmp. | |
15433 | ||
15434 | .*---------------------------------------------------------------------* | |
15435 | :h3.CER + DER encoding of REAL, 1.2E1 (primitive) | |
15436 | .*---------------------------------------------------------------------* | |
15437 | :xmp tab=0. | |
15438 | ||
15439 | <TC - CER + DER encoding of REAL, 1.2E1 (primitive)> | |
15440 | ||
15441 | <STATIC:ASN> | |
15442 | ||
15443 | TempA | |
15444 | ||
15445 | DEFINITIONS ::= | |
15446 | BEGIN | |
15447 | BERPDU ::= REAL | |
15448 | b BERPDU ::= 1.2E1 | |
15449 | ||
15450 | END | |
15451 | ||
15452 | <STATIC> | |
15453 | ||
15454 | import from TempA all; | |
15455 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15456 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15457 | ||
15458 | ||
15459 | ||
15460 | <TTCN_TC:EXEC> | |
15461 | ||
15462 | if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15463 | ||
15464 | <RESULT> | |
15465 | ||
15466 | Overall verdict: pass | |
15467 | ||
15468 | <END_TC> | |
15469 | ||
15470 | :exmp. | |
15471 | ||
15472 | .*---------------------------------------------------------------------* | |
15473 | :h3.CER + DER encoding of REAL, 0.12E2 (primitive) | |
15474 | .*---------------------------------------------------------------------* | |
15475 | :xmp tab=0. | |
15476 | ||
15477 | <TC - CER + DER encoding of REAL, 0.12E2 (primitive)> | |
15478 | ||
15479 | <STATIC:ASN> | |
15480 | ||
15481 | TempA | |
15482 | ||
15483 | DEFINITIONS ::= | |
15484 | BEGIN | |
15485 | BERPDU ::= REAL | |
15486 | b BERPDU ::= 0.12E2 | |
15487 | ||
15488 | END | |
15489 | ||
15490 | <STATIC> | |
15491 | ||
15492 | import from TempA all; | |
15493 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15494 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15495 | ||
15496 | ||
15497 | ||
15498 | <TTCN_TC:EXEC> | |
15499 | ||
15500 | if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15501 | ||
15502 | <RESULT> | |
15503 | ||
15504 | Overall verdict: pass | |
15505 | ||
15506 | <END_TC> | |
15507 | ||
15508 | :exmp. | |
15509 | ||
15510 | .*---------------------------------------------------------------------* | |
15511 | :h3.CER + DER encoding of REAL, 1.2E+1 (primitive) | |
15512 | .*---------------------------------------------------------------------* | |
15513 | :xmp tab=0. | |
15514 | ||
15515 | <TC - CER + DER encoding of REAL, 1.2E+1 (primitive)> | |
15516 | ||
15517 | <STATIC:ASN> | |
15518 | ||
15519 | TempA | |
15520 | ||
15521 | DEFINITIONS ::= | |
15522 | BEGIN | |
15523 | BERPDU ::= REAL | |
15524 | b BERPDU ::= 1.2E1 | |
15525 | ||
15526 | END | |
15527 | ||
15528 | <STATIC> | |
15529 | ||
15530 | import from TempA all; | |
15531 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15532 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15533 | ||
15534 | ||
15535 | ||
15536 | <TTCN_TC:EXEC> | |
15537 | ||
15538 | if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15539 | ||
15540 | <RESULT> | |
15541 | ||
15542 | Overall verdict: pass | |
15543 | ||
15544 | <END_TC> | |
15545 | ||
15546 | :exmp. | |
15547 | ||
15548 | .*---------------------------------------------------------------------* | |
15549 | :h3.CER + DER encoding of REAL, 0.12E+2 (primitive) | |
15550 | .*---------------------------------------------------------------------* | |
15551 | :xmp tab=0. | |
15552 | ||
15553 | <TC - CER + DER encoding of REAL, 0.12E+2 (primitive)> | |
15554 | ||
15555 | <STATIC:ASN> | |
15556 | ||
15557 | TempA | |
15558 | ||
15559 | DEFINITIONS ::= | |
15560 | BEGIN | |
15561 | BERPDU ::= REAL | |
15562 | b BERPDU ::= 0.12E2 | |
15563 | ||
15564 | END | |
15565 | ||
15566 | <STATIC> | |
15567 | ||
15568 | import from TempA all; | |
15569 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15570 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15571 | ||
15572 | ||
15573 | ||
15574 | <TTCN_TC:EXEC> | |
15575 | ||
15576 | if ((enc_DER_PDU(b) == '09070331322E452B30'O)and(enc_CER_PDU(b) == '09070331322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15577 | ||
15578 | <RESULT> | |
15579 | ||
15580 | Overall verdict: pass | |
15581 | ||
15582 | <END_TC> | |
15583 | ||
15584 | :exmp. | |
15585 | ||
15586 | .*---------------------------------------------------------------------* | |
15587 | :h3.CER + DER encoding of REAL, 0.34 (primitive) | |
15588 | .*---------------------------------------------------------------------* | |
15589 | :xmp tab=0. | |
15590 | ||
15591 | <TC - CER + DER encoding of REAL, 0.34 (primitive)> | |
15592 | ||
15593 | <STATIC:ASN> | |
15594 | ||
15595 | TempA | |
15596 | ||
15597 | DEFINITIONS ::= | |
15598 | BEGIN | |
15599 | BERPDU ::= REAL | |
15600 | b BERPDU ::= 0.34 | |
15601 | ||
15602 | END | |
15603 | ||
15604 | <STATIC> | |
15605 | ||
15606 | import from TempA all; | |
15607 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15608 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15609 | ||
15610 | ||
15611 | ||
15612 | <TTCN_TC:EXEC> | |
15613 | ||
15614 | if ((enc_DER_PDU(b) == '09070333342E452D32'O)and(enc_CER_PDU(b) == '09070333342E452D32'O)) {setverdict(pass);} else {setverdict(fail);} | |
15615 | ||
15616 | <RESULT> | |
15617 | ||
15618 | Overall verdict: pass | |
15619 | ||
15620 | <END_TC> | |
15621 | ||
15622 | :exmp. | |
15623 | ||
15624 | .*---------------------------------------------------------------------* | |
15625 | :h3.CER + DER encoding of REAL, 0.344 (primitive) | |
15626 | .*---------------------------------------------------------------------* | |
15627 | :xmp tab=0. | |
15628 | ||
15629 | <TC - CER + DER encoding of REAL, 0.344 (primitive)> | |
15630 | ||
15631 | <STATIC:ASN> | |
15632 | ||
15633 | TempA | |
15634 | ||
15635 | DEFINITIONS ::= | |
15636 | BEGIN | |
15637 | BERPDU ::= REAL | |
15638 | b BERPDU ::= 0.344 | |
15639 | ||
15640 | END | |
15641 | ||
15642 | <STATIC> | |
15643 | ||
15644 | import from TempA all; | |
15645 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15646 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15647 | ||
15648 | ||
15649 | ||
15650 | <TTCN_TC:EXEC> | |
15651 | ||
15652 | if ((enc_DER_PDU(b) == '0908033334342E452D33'O)and(enc_CER_PDU(b) == '0908033334342E452D33'O)) {setverdict(pass);} else {setverdict(fail);} | |
15653 | ||
15654 | <RESULT> | |
15655 | ||
15656 | Overall verdict: pass | |
15657 | ||
15658 | <END_TC> | |
15659 | ||
15660 | :exmp. | |
15661 | ||
15662 | .*---------------------------------------------------------------------* | |
15663 | :h3.CER + DER encoding of REAL, 0.345 (primitive) | |
15664 | .*---------------------------------------------------------------------* | |
15665 | :xmp tab=0. | |
15666 | ||
15667 | <TC - CER + DER encoding of REAL, 0.345 (primitive)> | |
15668 | ||
15669 | <STATIC:ASN> | |
15670 | ||
15671 | TempA | |
15672 | ||
15673 | DEFINITIONS ::= | |
15674 | BEGIN | |
15675 | BERPDU ::= REAL | |
15676 | b BERPDU ::= 0.345 | |
15677 | ||
15678 | END | |
15679 | ||
15680 | <STATIC> | |
15681 | ||
15682 | import from TempA all; | |
15683 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15684 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15685 | ||
15686 | ||
15687 | ||
15688 | <TTCN_TC:EXEC> | |
15689 | ||
15690 | if ((enc_DER_PDU(b) == '0908033334352E452D33'O)and(enc_CER_PDU(b) == '0908033334352E452D33'O)) {setverdict(pass);} else {setverdict(fail);} | |
15691 | ||
15692 | <RESULT> | |
15693 | ||
15694 | Overall verdict: pass | |
15695 | ||
15696 | <END_TC> | |
15697 | ||
15698 | :exmp. | |
15699 | ||
15700 | .*---------------------------------------------------------------------* | |
15701 | :h3.CER + DER encoding of REAL, 0.034 (primitive) | |
15702 | .*---------------------------------------------------------------------* | |
15703 | :xmp tab=0. | |
15704 | ||
15705 | <TC - CER + DER encoding of REAL, 0.034 (primitive)> | |
15706 | ||
15707 | <STATIC:ASN> | |
15708 | ||
15709 | TempA | |
15710 | ||
15711 | DEFINITIONS ::= | |
15712 | BEGIN | |
15713 | BERPDU ::= REAL | |
15714 | b BERPDU ::= 0.034 | |
15715 | ||
15716 | END | |
15717 | ||
15718 | <STATIC> | |
15719 | ||
15720 | import from TempA all; | |
15721 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15722 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15723 | ||
15724 | ||
15725 | ||
15726 | <TTCN_TC:EXEC> | |
15727 | ||
15728 | if ((enc_DER_PDU(b) == '09070333342E452D33'O)and(enc_CER_PDU(b) == '09070333342E452D33'O)) {setverdict(pass);} else {setverdict(fail);} | |
15729 | ||
15730 | <RESULT> | |
15731 | ||
15732 | Overall verdict: pass | |
15733 | ||
15734 | <END_TC> | |
15735 | ||
15736 | :exmp. | |
15737 | ||
15738 | .*---------------------------------------------------------------------* | |
15739 | :h3.CER + DER encoding of REAL, 0.0034 (primitive) | |
15740 | .*---------------------------------------------------------------------* | |
15741 | :xmp tab=0. | |
15742 | ||
15743 | <TC - CER + DER encoding of REAL, 0.0034 (primitive)> | |
15744 | ||
15745 | <STATIC:ASN> | |
15746 | ||
15747 | TempA | |
15748 | ||
15749 | DEFINITIONS ::= | |
15750 | BEGIN | |
15751 | BERPDU ::= REAL | |
15752 | b BERPDU ::= 0.0034 | |
15753 | ||
15754 | END | |
15755 | ||
15756 | <STATIC> | |
15757 | ||
15758 | import from TempA all; | |
15759 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15760 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15761 | ||
15762 | ||
15763 | ||
15764 | <TTCN_TC:EXEC> | |
15765 | ||
15766 | if ((enc_DER_PDU(b) == '09070333342E452D34'O)and(enc_CER_PDU(b) == '09070333342E452D34'O)) {setverdict(pass);} else {setverdict(fail);} | |
15767 | ||
15768 | <RESULT> | |
15769 | ||
15770 | Overall verdict: pass | |
15771 | ||
15772 | <END_TC> | |
15773 | ||
15774 | :exmp. | |
15775 | ||
15776 | .*---------------------------------------------------------------------* | |
15777 | :h3.CER + DER encoding of REAL, 0.304 (primitive) | |
15778 | .*---------------------------------------------------------------------* | |
15779 | :xmp tab=0. | |
15780 | ||
15781 | <TC - CER + DER encoding of REAL, 0.304 (primitive)> | |
15782 | ||
15783 | <STATIC:ASN> | |
15784 | ||
15785 | TempA | |
15786 | ||
15787 | DEFINITIONS ::= | |
15788 | BEGIN | |
15789 | BERPDU ::= REAL | |
15790 | b BERPDU ::= 0.304 | |
15791 | ||
15792 | END | |
15793 | ||
15794 | <STATIC> | |
15795 | ||
15796 | import from TempA all; | |
15797 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15798 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15799 | ||
15800 | ||
15801 | ||
15802 | <TTCN_TC:EXEC> | |
15803 | ||
15804 | if ((enc_DER_PDU(b) == '0908033330342E452D33'O)and(enc_CER_PDU(b) == '0908033330342E452D33'O)) {setverdict(pass);} else {setverdict(fail);} | |
15805 | ||
15806 | <RESULT> | |
15807 | ||
15808 | Overall verdict: pass | |
15809 | ||
15810 | <END_TC> | |
15811 | ||
15812 | :exmp. | |
15813 | ||
15814 | .*---------------------------------------------------------------------* | |
15815 | :h3.CER + DER encoding of REAL, 0.1234567890 (primitive) | |
15816 | .*---------------------------------------------------------------------* | |
15817 | :xmp tab=0. | |
15818 | ||
15819 | <TC - CER + DER encoding of REAL, 0.1234567890 (primitive)> | |
15820 | ||
15821 | <STATIC:ASN> | |
15822 | ||
15823 | TempA | |
15824 | ||
15825 | DEFINITIONS ::= | |
15826 | BEGIN | |
15827 | BERPDU ::= REAL | |
15828 | b BERPDU ::= 0.1234567890 | |
15829 | ||
15830 | END | |
15831 | ||
15832 | <STATIC> | |
15833 | ||
15834 | import from TempA all; | |
15835 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15836 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15837 | ||
15838 | ||
15839 | ||
15840 | <TTCN_TC:EXEC> | |
15841 | ||
15842 | if ((enc_DER_PDU(b) == '090E033132333435363738392E452D39'O)and(enc_CER_PDU(b) == '090E033132333435363738392E452D39'O)) {setverdict(pass);} else {setverdict(fail);} | |
15843 | ||
15844 | <RESULT> | |
15845 | ||
15846 | Overall verdict: pass | |
15847 | ||
15848 | <END_TC> | |
15849 | ||
15850 | :exmp. | |
15851 | ||
15852 | .*---------------------------------------------------------------------* | |
15853 | :h3.CER + DER encoding of REAL, 0.123456789 (primitive) | |
15854 | .*---------------------------------------------------------------------* | |
15855 | :xmp tab=0. | |
15856 | ||
15857 | <TC - CER + DER encoding of REAL, 0.123456789 (primitive)> | |
15858 | ||
15859 | <STATIC:ASN> | |
15860 | ||
15861 | TempA | |
15862 | ||
15863 | DEFINITIONS ::= | |
15864 | BEGIN | |
15865 | BERPDU ::= REAL | |
15866 | b BERPDU ::= 0.123456789 | |
15867 | ||
15868 | END | |
15869 | ||
15870 | <STATIC> | |
15871 | ||
15872 | import from TempA all; | |
15873 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15874 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15875 | ||
15876 | ||
15877 | ||
15878 | <TTCN_TC:EXEC> | |
15879 | ||
15880 | if ((enc_DER_PDU(b) == '090E033132333435363738392E452D39'O)and(enc_CER_PDU(b) == '090E033132333435363738392E452D39'O)) {setverdict(pass);} else {setverdict(fail);} | |
15881 | ||
15882 | <RESULT> | |
15883 | ||
15884 | Overall verdict: pass | |
15885 | ||
15886 | <END_TC> | |
15887 | ||
15888 | :exmp. | |
15889 | ||
15890 | .*---------------------------------------------------------------------* | |
15891 | :h3.CER + DER encoding of REAL, 0.0123456789 (primitive) | |
15892 | .*---------------------------------------------------------------------* | |
15893 | :xmp tab=0. | |
15894 | ||
15895 | <TC - CER + DER encoding of REAL, 0.0123456789 (primitive)> | |
15896 | ||
15897 | <STATIC:ASN> | |
15898 | ||
15899 | TempA | |
15900 | ||
15901 | DEFINITIONS ::= | |
15902 | BEGIN | |
15903 | BERPDU ::= REAL | |
15904 | b BERPDU ::= 0.0123456789 | |
15905 | ||
15906 | END | |
15907 | ||
15908 | <STATIC> | |
15909 | ||
15910 | import from TempA all; | |
15911 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15912 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15913 | ||
15914 | ||
15915 | ||
15916 | <TTCN_TC:EXEC> | |
15917 | ||
15918 | if ((enc_DER_PDU(b) == '090F033132333435363738392E452D3130'O)and(enc_CER_PDU(b) == '090F033132333435363738392E452D3130'O)) {setverdict(pass);} else {setverdict(fail);} | |
15919 | ||
15920 | <RESULT> | |
15921 | ||
15922 | Overall verdict: pass | |
15923 | ||
15924 | <END_TC> | |
15925 | ||
15926 | :exmp. | |
15927 | ||
15928 | .*---------------------------------------------------------------------* | |
15929 | :h3.CER + DER encoding of REAL, 123456789.0 (primitive) | |
15930 | .*---------------------------------------------------------------------* | |
15931 | :xmp tab=0. | |
15932 | ||
15933 | <TC - CER + DER encoding of REAL, 123456789.0 (primitive)> | |
15934 | ||
15935 | <STATIC:ASN> | |
15936 | ||
15937 | TempA | |
15938 | ||
15939 | DEFINITIONS ::= | |
15940 | BEGIN | |
15941 | BERPDU ::= REAL | |
15942 | b BERPDU ::= 123456789.0 | |
15943 | ||
15944 | END | |
15945 | ||
15946 | <STATIC> | |
15947 | ||
15948 | import from TempA all; | |
15949 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15950 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15951 | ||
15952 | ||
15953 | ||
15954 | <TTCN_TC:EXEC> | |
15955 | ||
15956 | if ((enc_DER_PDU(b) == '090E033132333435363738392E452B30'O)and(enc_CER_PDU(b) == '090E033132333435363738392E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15957 | ||
15958 | <RESULT> | |
15959 | ||
15960 | Overall verdict: pass | |
15961 | ||
15962 | <END_TC> | |
15963 | ||
15964 | :exmp. | |
15965 | ||
15966 | .*---------------------------------------------------------------------* | |
15967 | :h3.CER + DER encoding of REAL, 123456789 (primitive) | |
15968 | .*---------------------------------------------------------------------* | |
15969 | :xmp tab=0. | |
15970 | ||
15971 | <TC - CER + DER encoding of REAL, 123456789 (primitive)> | |
15972 | ||
15973 | <STATIC:ASN> | |
15974 | ||
15975 | TempA | |
15976 | ||
15977 | DEFINITIONS ::= | |
15978 | BEGIN | |
15979 | BERPDU ::= REAL | |
15980 | b BERPDU ::= 123456789 | |
15981 | ||
15982 | END | |
15983 | ||
15984 | <STATIC> | |
15985 | ||
15986 | import from TempA all; | |
15987 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
15988 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
15989 | ||
15990 | ||
15991 | ||
15992 | <TTCN_TC:EXEC> | |
15993 | ||
15994 | if ((enc_DER_PDU(b) == '090E033132333435363738392E452B30'O)and(enc_CER_PDU(b) == '090E033132333435363738392E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
15995 | ||
15996 | <RESULT> | |
15997 | ||
15998 | Overall verdict: pass | |
15999 | ||
16000 | <END_TC> | |
16001 | ||
16002 | :exmp. | |
16003 | ||
16004 | .*---------------------------------------------------------------------* | |
16005 | :h3.CER + DER encoding of REAL, 1234567890 (primitive) | |
16006 | .*---------------------------------------------------------------------* | |
16007 | :xmp tab=0. | |
16008 | ||
16009 | <TC - CER + DER encoding of REAL, 1234567890 (primitive)> | |
16010 | ||
16011 | <STATIC:ASN> | |
16012 | ||
16013 | TempA | |
16014 | ||
16015 | DEFINITIONS ::= | |
16016 | BEGIN | |
16017 | BERPDU ::= REAL | |
16018 | b BERPDU ::= 1234567890 | |
16019 | ||
16020 | END | |
16021 | ||
16022 | <STATIC> | |
16023 | ||
16024 | import from TempA all; | |
16025 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16026 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16027 | ||
16028 | ||
16029 | ||
16030 | <TTCN_TC:EXEC> | |
16031 | ||
16032 | if ((enc_DER_PDU(b) == '090D033132333435363738392E4531'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);} | |
16033 | ||
16034 | <RESULT> | |
16035 | ||
16036 | Overall verdict: pass | |
16037 | ||
16038 | <END_TC> | |
16039 | ||
16040 | :exmp. | |
16041 | ||
16042 | .*---------------------------------------------------------------------* | |
16043 | :h3.CER + DER encoding of REAL, 1234567890.0 (primitive) | |
16044 | .*---------------------------------------------------------------------* | |
16045 | :xmp tab=0. | |
16046 | ||
16047 | <TC - CER + DER encoding of REAL, 1234567890.0 (primitive)> | |
16048 | ||
16049 | <STATIC:ASN> | |
16050 | ||
16051 | TempA | |
16052 | ||
16053 | DEFINITIONS ::= | |
16054 | BEGIN | |
16055 | BERPDU ::= REAL | |
16056 | b BERPDU ::= 1234567890.0 | |
16057 | ||
16058 | END | |
16059 | ||
16060 | <STATIC> | |
16061 | ||
16062 | import from TempA all; | |
16063 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16064 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16065 | ||
16066 | ||
16067 | ||
16068 | <TTCN_TC:EXEC> | |
16069 | ||
16070 | if ((enc_DER_PDU(b) == '090D033132333435363738392E4531'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);} | |
16071 | ||
16072 | <RESULT> | |
16073 | ||
16074 | Overall verdict: pass | |
16075 | ||
16076 | <END_TC> | |
16077 | ||
16078 | :exmp. | |
16079 | ||
16080 | .*---------------------------------------------------------------------* | |
16081 | :h3.CER + DER encoding of REAL, 1234567890.00 (primitive) | |
16082 | .*---------------------------------------------------------------------* | |
16083 | :xmp tab=0. | |
16084 | ||
16085 | <TC - CER + DER encoding of REAL, 1234567890.00 (primitive)> | |
16086 | ||
16087 | <STATIC:ASN> | |
16088 | ||
16089 | TempA | |
16090 | ||
16091 | DEFINITIONS ::= | |
16092 | BEGIN | |
16093 | BERPDU ::= REAL | |
16094 | b BERPDU ::= 1234567890.00 | |
16095 | ||
16096 | END | |
16097 | ||
16098 | <STATIC> | |
16099 | ||
16100 | import from TempA all; | |
16101 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16102 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16103 | ||
16104 | ||
16105 | ||
16106 | <TTCN_TC:EXEC> | |
16107 | ||
16108 | if ((enc_DER_PDU(b) == '090D033132333435363738392E4531'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);} | |
16109 | ||
16110 | <RESULT> | |
16111 | ||
16112 | Overall verdict: pass | |
16113 | ||
16114 | <END_TC> | |
16115 | ||
16116 | :exmp. | |
16117 | ||
16118 | .*---------------------------------------------------------------------* | |
16119 | :h3.CER + DER encoding of REAL, 12345678900.0 (primitive) | |
16120 | .*---------------------------------------------------------------------* | |
16121 | :xmp tab=0. | |
16122 | ||
16123 | <TC - CER + DER encoding of REAL, 12345678900.0 (primitive)> | |
16124 | ||
16125 | <STATIC:ASN> | |
16126 | ||
16127 | TempA | |
16128 | ||
16129 | DEFINITIONS ::= | |
16130 | BEGIN | |
16131 | BERPDU ::= REAL | |
16132 | b BERPDU ::= 12345678900.0 | |
16133 | ||
16134 | END | |
16135 | ||
16136 | <STATIC> | |
16137 | ||
16138 | import from TempA all; | |
16139 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16140 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16141 | ||
16142 | ||
16143 | ||
16144 | <TTCN_TC:EXEC> | |
16145 | ||
16146 | if ((enc_DER_PDU(b) == '090D033132333435363738392E4532'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);} | |
16147 | ||
16148 | <RESULT> | |
16149 | ||
16150 | Overall verdict: pass | |
16151 | ||
16152 | <END_TC> | |
16153 | ||
16154 | :exmp. | |
16155 | ||
16156 | .*---------------------------------------------------------------------* | |
16157 | :h3.CER + DER encoding of REAL, 12345678900.0 (primitive) | |
16158 | .*---------------------------------------------------------------------* | |
16159 | :xmp tab=0. | |
16160 | ||
16161 | <TC - CER + DER encoding of REAL, 12345678900.0 (primitive)> | |
16162 | ||
16163 | <STATIC:ASN> | |
16164 | ||
16165 | TempA | |
16166 | ||
16167 | DEFINITIONS ::= | |
16168 | BEGIN | |
16169 | BERPDU ::= REAL | |
16170 | b BERPDU ::=12345678900.0 | |
16171 | ||
16172 | END | |
16173 | ||
16174 | <STATIC> | |
16175 | ||
16176 | import from TempA all; | |
16177 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16178 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16179 | ||
16180 | ||
16181 | ||
16182 | <TTCN_TC:EXEC> | |
16183 | ||
16184 | if ((enc_DER_PDU(b) == '090D033132333435363738392E4532'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);} | |
16185 | ||
16186 | <RESULT> | |
16187 | ||
16188 | Overall verdict: pass | |
16189 | ||
16190 | <END_TC> | |
16191 | ||
16192 | :exmp. | |
16193 | ||
16194 | .*---------------------------------------------------------------------* | |
16195 | :h3.CER + DER encoding of REAL, 12345678900.00 (primitive) | |
16196 | .*---------------------------------------------------------------------* | |
16197 | :xmp tab=0. | |
16198 | ||
16199 | <TC - CER + DER encoding of REAL, 12345678900.00 (primitive)> | |
16200 | ||
16201 | <STATIC:ASN> | |
16202 | ||
16203 | TempA | |
16204 | ||
16205 | DEFINITIONS ::= | |
16206 | BEGIN | |
16207 | BERPDU ::= REAL | |
16208 | b BERPDU ::= 12345678900.00 | |
16209 | ||
16210 | END | |
16211 | ||
16212 | <STATIC> | |
16213 | ||
16214 | import from TempA all; | |
16215 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16216 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16217 | ||
16218 | ||
16219 | ||
16220 | <TTCN_TC:EXEC> | |
16221 | ||
16222 | if ((enc_DER_PDU(b) == '090D033132333435363738392E4532'O)and(enc_CER_PDU(b) == '090D033132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);} | |
16223 | ||
16224 | <RESULT> | |
16225 | ||
16226 | Overall verdict: pass | |
16227 | ||
16228 | <END_TC> | |
16229 | ||
16230 | :exmp. | |
16231 | ||
16232 | .*---------------------------------------------------------------------* | |
16233 | :h3.CER + DER encoding of REAL, -12 (primitive) | |
16234 | .*---------------------------------------------------------------------* | |
16235 | :xmp tab=0. | |
16236 | ||
16237 | <TC - CER + DER encoding of REAL, -12 (primitive)> | |
16238 | ||
16239 | <STATIC:ASN> | |
16240 | ||
16241 | TempA | |
16242 | ||
16243 | DEFINITIONS ::= | |
16244 | BEGIN | |
16245 | BERPDU ::= REAL | |
16246 | b BERPDU ::= -12 | |
16247 | ||
16248 | END | |
16249 | ||
16250 | <STATIC> | |
16251 | ||
16252 | import from TempA all; | |
16253 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16254 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16255 | ||
16256 | ||
16257 | ||
16258 | <TTCN_TC:EXEC> | |
16259 | ||
16260 | if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
16261 | ||
16262 | <RESULT> | |
16263 | ||
16264 | Overall verdict: pass | |
16265 | ||
16266 | <END_TC> | |
16267 | ||
16268 | :exmp. | |
16269 | ||
16270 | .*---------------------------------------------------------------------* | |
16271 | :h3.CER + DER encoding of REAL, -12.0 (primitive) | |
16272 | .*---------------------------------------------------------------------* | |
16273 | :xmp tab=0. | |
16274 | ||
16275 | <TC - CER + DER encoding of REAL, -12.0 (primitive)> | |
16276 | ||
16277 | <STATIC:ASN> | |
16278 | ||
16279 | TempA | |
16280 | ||
16281 | DEFINITIONS ::= | |
16282 | BEGIN | |
16283 | BERPDU ::= REAL | |
16284 | b BERPDU ::= -12.0 | |
16285 | ||
16286 | END | |
16287 | ||
16288 | <STATIC> | |
16289 | ||
16290 | import from TempA all; | |
16291 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16292 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16293 | ||
16294 | ||
16295 | ||
16296 | <TTCN_TC:EXEC> | |
16297 | ||
16298 | if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
16299 | ||
16300 | <RESULT> | |
16301 | ||
16302 | Overall verdict: pass | |
16303 | ||
16304 | <END_TC> | |
16305 | ||
16306 | :exmp. | |
16307 | ||
16308 | .*---------------------------------------------------------------------* | |
16309 | :h3.CER + DER encoding of REAL, -12.0E0 (primitive) | |
16310 | .*---------------------------------------------------------------------* | |
16311 | :xmp tab=0. | |
16312 | ||
16313 | <TC - CER + DER encoding of REAL, -12.0E0 (primitive)> | |
16314 | ||
16315 | <STATIC:ASN> | |
16316 | ||
16317 | TempA | |
16318 | ||
16319 | DEFINITIONS ::= | |
16320 | BEGIN | |
16321 | BERPDU ::= REAL | |
16322 | b BERPDU ::= -12.0E0 | |
16323 | ||
16324 | END | |
16325 | ||
16326 | <STATIC> | |
16327 | ||
16328 | import from TempA all; | |
16329 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16330 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16331 | ||
16332 | ||
16333 | ||
16334 | <TTCN_TC:EXEC> | |
16335 | ||
16336 | if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
16337 | ||
16338 | <RESULT> | |
16339 | ||
16340 | Overall verdict: pass | |
16341 | ||
16342 | <END_TC> | |
16343 | ||
16344 | :exmp. | |
16345 | ||
16346 | .*---------------------------------------------------------------------* | |
16347 | :h3.CER + DER encoding of REAL, -1.2E1 (primitive) | |
16348 | .*---------------------------------------------------------------------* | |
16349 | :xmp tab=0. | |
16350 | ||
16351 | <TC - CER + DER encoding of REAL, -1.2E1 (primitive)> | |
16352 | ||
16353 | <STATIC:ASN> | |
16354 | ||
16355 | TempA | |
16356 | ||
16357 | DEFINITIONS ::= | |
16358 | BEGIN | |
16359 | BERPDU ::= REAL | |
16360 | b BERPDU ::= -1.2E1 | |
16361 | ||
16362 | END | |
16363 | ||
16364 | <STATIC> | |
16365 | ||
16366 | import from TempA all; | |
16367 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16368 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16369 | ||
16370 | ||
16371 | ||
16372 | <TTCN_TC:EXEC> | |
16373 | ||
16374 | if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
16375 | ||
16376 | <RESULT> | |
16377 | ||
16378 | Overall verdict: pass | |
16379 | ||
16380 | <END_TC> | |
16381 | ||
16382 | :exmp. | |
16383 | ||
16384 | .*---------------------------------------------------------------------* | |
16385 | :h3.CER + DER encoding of REAL, -0.12E2 (primitive) | |
16386 | .*---------------------------------------------------------------------* | |
16387 | :xmp tab=0. | |
16388 | ||
16389 | <TC - CER + DER encoding of REAL, -0.12E2 (primitive)> | |
16390 | ||
16391 | <STATIC:ASN> | |
16392 | ||
16393 | TempA | |
16394 | ||
16395 | DEFINITIONS ::= | |
16396 | BEGIN | |
16397 | BERPDU ::= REAL | |
16398 | b BERPDU ::= -0.12E2 | |
16399 | ||
16400 | END | |
16401 | ||
16402 | <STATIC> | |
16403 | ||
16404 | import from TempA all; | |
16405 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16406 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16407 | ||
16408 | ||
16409 | ||
16410 | <TTCN_TC:EXEC> | |
16411 | ||
16412 | if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
16413 | ||
16414 | <RESULT> | |
16415 | ||
16416 | Overall verdict: pass | |
16417 | ||
16418 | <END_TC> | |
16419 | ||
16420 | :exmp. | |
16421 | ||
16422 | .*---------------------------------------------------------------------* | |
16423 | :h3.CER + DER encoding of REAL, -1.2E+1 (primitive) | |
16424 | .*---------------------------------------------------------------------* | |
16425 | :xmp tab=0. | |
16426 | ||
16427 | <TC - CER + DER encoding of REAL, -1.2E+1 (primitive)> | |
16428 | ||
16429 | <STATIC:ASN> | |
16430 | ||
16431 | TempA | |
16432 | ||
16433 | DEFINITIONS ::= | |
16434 | BEGIN | |
16435 | BERPDU ::= REAL | |
16436 | b BERPDU ::= -1.2E1 | |
16437 | ||
16438 | END | |
16439 | ||
16440 | <STATIC> | |
16441 | ||
16442 | import from TempA all; | |
16443 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16444 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16445 | ||
16446 | ||
16447 | ||
16448 | <TTCN_TC:EXEC> | |
16449 | ||
16450 | if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
16451 | ||
16452 | <RESULT> | |
16453 | ||
16454 | Overall verdict: pass | |
16455 | ||
16456 | <END_TC> | |
16457 | ||
16458 | :exmp. | |
16459 | ||
16460 | .*---------------------------------------------------------------------* | |
16461 | :h3.CER + DER encoding of REAL, -0.12E+2 (primitive) | |
16462 | .*---------------------------------------------------------------------* | |
16463 | :xmp tab=0. | |
16464 | ||
16465 | <TC - CER + DER encoding of REAL, -0.12E+2 (primitive)> | |
16466 | ||
16467 | <STATIC:ASN> | |
16468 | ||
16469 | TempA | |
16470 | ||
16471 | DEFINITIONS ::= | |
16472 | BEGIN | |
16473 | BERPDU ::= REAL | |
16474 | b BERPDU ::= -0.12E2 | |
16475 | ||
16476 | END | |
16477 | ||
16478 | <STATIC> | |
16479 | ||
16480 | import from TempA all; | |
16481 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16482 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16483 | ||
16484 | ||
16485 | ||
16486 | <TTCN_TC:EXEC> | |
16487 | ||
16488 | if ((enc_DER_PDU(b) == '0908032D31322E452B30'O)and(enc_CER_PDU(b) == '0908032D31322E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
16489 | ||
16490 | <RESULT> | |
16491 | ||
16492 | Overall verdict: pass | |
16493 | ||
16494 | <END_TC> | |
16495 | ||
16496 | :exmp. | |
16497 | ||
16498 | .*---------------------------------------------------------------------* | |
16499 | :h3.CER + DER encoding of REAL, -0.34 (primitive) | |
16500 | .*---------------------------------------------------------------------* | |
16501 | :xmp tab=0. | |
16502 | ||
16503 | <TC - CER + DER encoding of REAL, -0.34 (primitive)> | |
16504 | ||
16505 | <STATIC:ASN> | |
16506 | ||
16507 | TempA | |
16508 | ||
16509 | DEFINITIONS ::= | |
16510 | BEGIN | |
16511 | BERPDU ::= REAL | |
16512 | b BERPDU ::= -0.34 | |
16513 | ||
16514 | END | |
16515 | ||
16516 | <STATIC> | |
16517 | ||
16518 | import from TempA all; | |
16519 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16520 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16521 | ||
16522 | ||
16523 | ||
16524 | <TTCN_TC:EXEC> | |
16525 | ||
16526 | if ((enc_DER_PDU(b) == '0908032D33342E452D32'O)and(enc_CER_PDU(b) == '0908032D33342E452D32'O)) {setverdict(pass);} else {setverdict(fail);} | |
16527 | ||
16528 | <RESULT> | |
16529 | ||
16530 | Overall verdict: pass | |
16531 | ||
16532 | <END_TC> | |
16533 | ||
16534 | :exmp. | |
16535 | ||
16536 | .*---------------------------------------------------------------------* | |
16537 | :h3.CER + DER encoding of REAL, -0.344 (primitive) | |
16538 | .*---------------------------------------------------------------------* | |
16539 | :xmp tab=0. | |
16540 | ||
16541 | <TC - CER + DER encoding of REAL, -0.344 (primitive)> | |
16542 | ||
16543 | <STATIC:ASN> | |
16544 | ||
16545 | TempA | |
16546 | ||
16547 | DEFINITIONS ::= | |
16548 | BEGIN | |
16549 | BERPDU ::= REAL | |
16550 | b BERPDU ::= -0.344 | |
16551 | ||
16552 | END | |
16553 | ||
16554 | <STATIC> | |
16555 | ||
16556 | import from TempA all; | |
16557 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16558 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16559 | ||
16560 | ||
16561 | ||
16562 | <TTCN_TC:EXEC> | |
16563 | ||
16564 | if ((enc_DER_PDU(b) == '0909032D3334342E452D33'O)and(enc_CER_PDU(b) == '0909032D3334342E452D33'O)) {setverdict(pass);} else {setverdict(fail);} | |
16565 | ||
16566 | <RESULT> | |
16567 | ||
16568 | Overall verdict: pass | |
16569 | ||
16570 | <END_TC> | |
16571 | ||
16572 | :exmp. | |
16573 | ||
16574 | .*---------------------------------------------------------------------* | |
16575 | :h3.CER + DER encoding of REAL, -0.345 (primitive) | |
16576 | .*---------------------------------------------------------------------* | |
16577 | :xmp tab=0. | |
16578 | ||
16579 | <TC - CER + DER encoding of REAL, -0.345 (primitive)> | |
16580 | ||
16581 | <STATIC:ASN> | |
16582 | ||
16583 | TempA | |
16584 | ||
16585 | DEFINITIONS ::= | |
16586 | BEGIN | |
16587 | BERPDU ::= REAL | |
16588 | b BERPDU ::= -0.345 | |
16589 | ||
16590 | END | |
16591 | ||
16592 | <STATIC> | |
16593 | ||
16594 | import from TempA all; | |
16595 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16596 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16597 | ||
16598 | ||
16599 | ||
16600 | <TTCN_TC:EXEC> | |
16601 | ||
16602 | if ((enc_DER_PDU(b) == '0909032D3334352E452D33'O)and(enc_CER_PDU(b) == '0909032D3334352E452D33'O)) {setverdict(pass);} else {setverdict(fail);} | |
16603 | ||
16604 | <RESULT> | |
16605 | ||
16606 | Overall verdict: pass | |
16607 | ||
16608 | <END_TC> | |
16609 | ||
16610 | :exmp. | |
16611 | ||
16612 | .*---------------------------------------------------------------------* | |
16613 | :h3.CER + DER encoding of REAL, -0.034 (primitive) | |
16614 | .*---------------------------------------------------------------------* | |
16615 | :xmp tab=0. | |
16616 | ||
16617 | <TC - CER + DER encoding of REAL, -0.034 (primitive)> | |
16618 | ||
16619 | <STATIC:ASN> | |
16620 | ||
16621 | TempA | |
16622 | ||
16623 | DEFINITIONS ::= | |
16624 | BEGIN | |
16625 | BERPDU ::= REAL | |
16626 | b BERPDU ::= -0.034 | |
16627 | ||
16628 | END | |
16629 | ||
16630 | <STATIC> | |
16631 | ||
16632 | import from TempA all; | |
16633 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16634 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16635 | ||
16636 | ||
16637 | ||
16638 | <TTCN_TC:EXEC> | |
16639 | ||
16640 | if ((enc_DER_PDU(b) == '0908032D33342E452D33'O)and(enc_CER_PDU(b) == '0908032D33342E452D33'O)) {setverdict(pass);} else {setverdict(fail);} | |
16641 | ||
16642 | <RESULT> | |
16643 | ||
16644 | Overall verdict: pass | |
16645 | ||
16646 | <END_TC> | |
16647 | ||
16648 | :exmp. | |
16649 | ||
16650 | .*---------------------------------------------------------------------* | |
16651 | :h3.CER + DER encoding of REAL, -0.0034 (primitive) | |
16652 | .*---------------------------------------------------------------------* | |
16653 | :xmp tab=0. | |
16654 | ||
16655 | <TC - CER + DER encoding of REAL, -0.0034 (primitive)> | |
16656 | ||
16657 | <STATIC:ASN> | |
16658 | ||
16659 | TempA | |
16660 | ||
16661 | DEFINITIONS ::= | |
16662 | BEGIN | |
16663 | BERPDU ::= REAL | |
16664 | b BERPDU ::= -0.0034 | |
16665 | ||
16666 | END | |
16667 | ||
16668 | <STATIC> | |
16669 | ||
16670 | import from TempA all; | |
16671 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16672 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16673 | ||
16674 | ||
16675 | ||
16676 | <TTCN_TC:EXEC> | |
16677 | ||
16678 | if ((enc_DER_PDU(b) == '0908032D33342E452D34'O)and(enc_CER_PDU(b) == '0908032D33342E452D34'O)) {setverdict(pass);} else {setverdict(fail);} | |
16679 | ||
16680 | <RESULT> | |
16681 | ||
16682 | Overall verdict: pass | |
16683 | ||
16684 | <END_TC> | |
16685 | ||
16686 | :exmp. | |
16687 | ||
16688 | .*---------------------------------------------------------------------* | |
16689 | :h3.CER + DER encoding of REAL, -0.304 (primitive) | |
16690 | .*---------------------------------------------------------------------* | |
16691 | :xmp tab=0. | |
16692 | ||
16693 | <TC - CER + DER encoding of REAL, -0.304 (primitive)> | |
16694 | ||
16695 | <STATIC:ASN> | |
16696 | ||
16697 | TempA | |
16698 | ||
16699 | DEFINITIONS ::= | |
16700 | BEGIN | |
16701 | BERPDU ::= REAL | |
16702 | b BERPDU ::= -0.304 | |
16703 | ||
16704 | END | |
16705 | ||
16706 | <STATIC> | |
16707 | ||
16708 | import from TempA all; | |
16709 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16710 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16711 | ||
16712 | ||
16713 | ||
16714 | <TTCN_TC:EXEC> | |
16715 | ||
16716 | if ((enc_DER_PDU(b) == '0909032D3330342E452D33'O)and(enc_CER_PDU(b) == '0909032D3330342E452D33'O)) {setverdict(pass);} else {setverdict(fail);} | |
16717 | ||
16718 | <RESULT> | |
16719 | ||
16720 | Overall verdict: pass | |
16721 | ||
16722 | <END_TC> | |
16723 | ||
16724 | :exmp. | |
16725 | ||
16726 | .*---------------------------------------------------------------------* | |
16727 | :h3.CER + DER encoding of REAL, -0.1234567890 (primitive) | |
16728 | .*---------------------------------------------------------------------* | |
16729 | :xmp tab=0. | |
16730 | ||
16731 | <TC - CER + DER encoding of REAL, -0.1234567890 (primitive)> | |
16732 | ||
16733 | <STATIC:ASN> | |
16734 | ||
16735 | TempA | |
16736 | ||
16737 | DEFINITIONS ::= | |
16738 | BEGIN | |
16739 | BERPDU ::= REAL | |
16740 | b BERPDU ::= -0.1234567890 | |
16741 | ||
16742 | END | |
16743 | ||
16744 | <STATIC> | |
16745 | ||
16746 | import from TempA all; | |
16747 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16748 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16749 | ||
16750 | ||
16751 | ||
16752 | <TTCN_TC:EXEC> | |
16753 | ||
16754 | if ((enc_DER_PDU(b) == '090F032D3132333435363738392E452D39'O)and(enc_CER_PDU(b) == '090F032D3132333435363738392E452D39'O)) {setverdict(pass);} else {setverdict(fail);} | |
16755 | ||
16756 | <RESULT> | |
16757 | ||
16758 | Overall verdict: pass | |
16759 | ||
16760 | <END_TC> | |
16761 | ||
16762 | :exmp. | |
16763 | ||
16764 | .*---------------------------------------------------------------------* | |
16765 | :h3.CER + DER encoding of REAL, -0.123456789 (primitive) | |
16766 | .*---------------------------------------------------------------------* | |
16767 | :xmp tab=0. | |
16768 | ||
16769 | <TC - CER + DER encoding of REAL, -0.123456789 (primitive)> | |
16770 | ||
16771 | <STATIC:ASN> | |
16772 | ||
16773 | TempA | |
16774 | ||
16775 | DEFINITIONS ::= | |
16776 | BEGIN | |
16777 | BERPDU ::= REAL | |
16778 | b BERPDU ::= -0.123456789 | |
16779 | ||
16780 | END | |
16781 | ||
16782 | <STATIC> | |
16783 | ||
16784 | import from TempA all; | |
16785 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16786 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16787 | ||
16788 | ||
16789 | ||
16790 | <TTCN_TC:EXEC> | |
16791 | ||
16792 | if ((enc_DER_PDU(b) == '090F032D3132333435363738392E452D39'O)and(enc_CER_PDU(b) == '090F032D3132333435363738392E452D39'O)) {setverdict(pass);} else {setverdict(fail);} | |
16793 | ||
16794 | <RESULT> | |
16795 | ||
16796 | Overall verdict: pass | |
16797 | ||
16798 | <END_TC> | |
16799 | ||
16800 | :exmp. | |
16801 | ||
16802 | .*---------------------------------------------------------------------* | |
16803 | :h3.CER + DER encoding of REAL, -0.0123456789 (primitive) | |
16804 | .*---------------------------------------------------------------------* | |
16805 | :xmp tab=0. | |
16806 | ||
16807 | <TC - CER + DER encoding of REAL, -0.0123456789 (primitive)> | |
16808 | ||
16809 | <STATIC:ASN> | |
16810 | ||
16811 | TempA | |
16812 | ||
16813 | DEFINITIONS ::= | |
16814 | BEGIN | |
16815 | BERPDU ::= REAL | |
16816 | b BERPDU ::= -0.0123456789 | |
16817 | ||
16818 | END | |
16819 | ||
16820 | <STATIC> | |
16821 | ||
16822 | import from TempA all; | |
16823 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16824 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16825 | ||
16826 | ||
16827 | ||
16828 | <TTCN_TC:EXEC> | |
16829 | ||
16830 | if ((enc_DER_PDU(b) == '0910032D3132333435363738392E452D3130'O)and(enc_CER_PDU(b) == '0910032D3132333435363738392E452D3130'O)) {setverdict(pass);} else {setverdict(fail);} | |
16831 | ||
16832 | <RESULT> | |
16833 | ||
16834 | Overall verdict: pass | |
16835 | ||
16836 | <END_TC> | |
16837 | ||
16838 | :exmp. | |
16839 | ||
16840 | .*---------------------------------------------------------------------* | |
16841 | :h3.CER + DER encoding of REAL, -123456789.0 (primitive) | |
16842 | .*---------------------------------------------------------------------* | |
16843 | :xmp tab=0. | |
16844 | ||
16845 | <TC - CER + DER encoding of REAL, -123456789.0 (primitive)> | |
16846 | ||
16847 | <STATIC:ASN> | |
16848 | ||
16849 | TempA | |
16850 | ||
16851 | DEFINITIONS ::= | |
16852 | BEGIN | |
16853 | BERPDU ::= REAL | |
16854 | b BERPDU ::= -123456789.0 | |
16855 | ||
16856 | END | |
16857 | ||
16858 | <STATIC> | |
16859 | ||
16860 | import from TempA all; | |
16861 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16862 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16863 | ||
16864 | ||
16865 | ||
16866 | <TTCN_TC:EXEC> | |
16867 | ||
16868 | if ((enc_DER_PDU(b) == '090F032D3132333435363738392E452B30'O)and(enc_CER_PDU(b) == '090F032D3132333435363738392E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
16869 | ||
16870 | <RESULT> | |
16871 | ||
16872 | Overall verdict: pass | |
16873 | ||
16874 | <END_TC> | |
16875 | ||
16876 | :exmp. | |
16877 | ||
16878 | .*---------------------------------------------------------------------* | |
16879 | :h3.CER + DER encoding of REAL, -123456789 (primitive) | |
16880 | .*---------------------------------------------------------------------* | |
16881 | :xmp tab=0. | |
16882 | ||
16883 | <TC - CER + DER encoding of REAL, -123456789 (primitive)> | |
16884 | ||
16885 | <STATIC:ASN> | |
16886 | ||
16887 | TempA | |
16888 | ||
16889 | DEFINITIONS ::= | |
16890 | BEGIN | |
16891 | BERPDU ::= REAL | |
16892 | b BERPDU ::= -123456789 | |
16893 | ||
16894 | END | |
16895 | ||
16896 | <STATIC> | |
16897 | ||
16898 | import from TempA all; | |
16899 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16900 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16901 | ||
16902 | ||
16903 | ||
16904 | <TTCN_TC:EXEC> | |
16905 | ||
16906 | if ((enc_DER_PDU(b) == '090F032D3132333435363738392E452B30'O)and(enc_CER_PDU(b) == '090F032D3132333435363738392E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
16907 | ||
16908 | <RESULT> | |
16909 | ||
16910 | Overall verdict: pass | |
16911 | ||
16912 | <END_TC> | |
16913 | ||
16914 | :exmp. | |
16915 | ||
16916 | .*---------------------------------------------------------------------* | |
16917 | :h3.CER + DER encoding of REAL, -1234567890 (primitive) | |
16918 | .*---------------------------------------------------------------------* | |
16919 | :xmp tab=0. | |
16920 | ||
16921 | <TC - CER + DER encoding of REAL, -1234567890 (primitive)> | |
16922 | ||
16923 | <STATIC:ASN> | |
16924 | ||
16925 | TempA | |
16926 | ||
16927 | DEFINITIONS ::= | |
16928 | BEGIN | |
16929 | BERPDU ::= REAL | |
16930 | b BERPDU ::= -1234567890 | |
16931 | ||
16932 | END | |
16933 | ||
16934 | <STATIC> | |
16935 | ||
16936 | import from TempA all; | |
16937 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16938 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16939 | ||
16940 | ||
16941 | ||
16942 | <TTCN_TC:EXEC> | |
16943 | ||
16944 | if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4531'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);} | |
16945 | ||
16946 | <RESULT> | |
16947 | ||
16948 | Overall verdict: pass | |
16949 | ||
16950 | <END_TC> | |
16951 | ||
16952 | :exmp. | |
16953 | ||
16954 | .*---------------------------------------------------------------------* | |
16955 | :h3.CER + DER encoding of REAL, -1234567890.0 (primitive) | |
16956 | .*---------------------------------------------------------------------* | |
16957 | :xmp tab=0. | |
16958 | ||
16959 | <TC - CER + DER encoding of REAL, -1234567890.0 (primitive)> | |
16960 | ||
16961 | <STATIC:ASN> | |
16962 | ||
16963 | TempA | |
16964 | ||
16965 | DEFINITIONS ::= | |
16966 | BEGIN | |
16967 | BERPDU ::= REAL | |
16968 | b BERPDU ::= -1234567890.0 | |
16969 | ||
16970 | END | |
16971 | ||
16972 | <STATIC> | |
16973 | ||
16974 | import from TempA all; | |
16975 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
16976 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
16977 | ||
16978 | ||
16979 | ||
16980 | <TTCN_TC:EXEC> | |
16981 | ||
16982 | if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4531'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);} | |
16983 | ||
16984 | <RESULT> | |
16985 | ||
16986 | Overall verdict: pass | |
16987 | ||
16988 | <END_TC> | |
16989 | ||
16990 | :exmp. | |
16991 | ||
16992 | .*---------------------------------------------------------------------* | |
16993 | :h3.CER + DER encoding of REAL, -1234567890.00 (primitive) | |
16994 | .*---------------------------------------------------------------------* | |
16995 | :xmp tab=0. | |
16996 | ||
16997 | <TC - CER + DER encoding of REAL, -1234567890.00 (primitive)> | |
16998 | ||
16999 | <STATIC:ASN> | |
17000 | ||
17001 | TempA | |
17002 | ||
17003 | DEFINITIONS ::= | |
17004 | BEGIN | |
17005 | BERPDU ::= REAL | |
17006 | b BERPDU ::= -1234567890.00 | |
17007 | ||
17008 | END | |
17009 | ||
17010 | <STATIC> | |
17011 | ||
17012 | import from TempA all; | |
17013 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17014 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17015 | ||
17016 | ||
17017 | ||
17018 | <TTCN_TC:EXEC> | |
17019 | ||
17020 | if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4531'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4531'O)) {setverdict(pass);} else {setverdict(fail);} | |
17021 | ||
17022 | <RESULT> | |
17023 | ||
17024 | Overall verdict: pass | |
17025 | ||
17026 | <END_TC> | |
17027 | ||
17028 | :exmp. | |
17029 | ||
17030 | .*---------------------------------------------------------------------* | |
17031 | :h3.CER + DER encoding of REAL, -12345678900.0 (primitive) | |
17032 | .*---------------------------------------------------------------------* | |
17033 | :xmp tab=0. | |
17034 | ||
17035 | <TC - CER + DER encoding of REAL, -12345678900.0 (primitive)> | |
17036 | ||
17037 | <STATIC:ASN> | |
17038 | ||
17039 | TempA | |
17040 | ||
17041 | DEFINITIONS ::= | |
17042 | BEGIN | |
17043 | BERPDU ::= REAL | |
17044 | b BERPDU ::= -12345678900.0 | |
17045 | ||
17046 | END | |
17047 | ||
17048 | <STATIC> | |
17049 | ||
17050 | import from TempA all; | |
17051 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17052 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17053 | ||
17054 | ||
17055 | ||
17056 | <TTCN_TC:EXEC> | |
17057 | ||
17058 | if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4532'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);} | |
17059 | ||
17060 | <RESULT> | |
17061 | ||
17062 | Overall verdict: pass | |
17063 | ||
17064 | <END_TC> | |
17065 | ||
17066 | :exmp. | |
17067 | ||
17068 | .*---------------------------------------------------------------------* | |
17069 | :h3.CER + DER encoding of REAL, -12345678900.0 (primitive) | |
17070 | .*---------------------------------------------------------------------* | |
17071 | :xmp tab=0. | |
17072 | ||
17073 | <TC - CER + DER encoding of REAL, -12345678900.0 (primitive)> | |
17074 | ||
17075 | <STATIC:ASN> | |
17076 | ||
17077 | TempA | |
17078 | ||
17079 | DEFINITIONS ::= | |
17080 | BEGIN | |
17081 | BERPDU ::= REAL | |
17082 | b BERPDU ::= -12345678900.0 | |
17083 | ||
17084 | END | |
17085 | ||
17086 | <STATIC> | |
17087 | ||
17088 | import from TempA all; | |
17089 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17090 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17091 | ||
17092 | ||
17093 | ||
17094 | <TTCN_TC:EXEC> | |
17095 | ||
17096 | if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4532'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);} | |
17097 | ||
17098 | <RESULT> | |
17099 | ||
17100 | Overall verdict: pass | |
17101 | ||
17102 | <END_TC> | |
17103 | ||
17104 | :exmp. | |
17105 | ||
17106 | .*---------------------------------------------------------------------* | |
17107 | :h3.CER + DER encoding of REAL, -12345678900.00 (primitive) | |
17108 | .*---------------------------------------------------------------------* | |
17109 | :xmp tab=0. | |
17110 | ||
17111 | <TC - CER + DER encoding of REAL, -12345678900.00 (primitive)> | |
17112 | ||
17113 | <STATIC:ASN> | |
17114 | ||
17115 | TempA | |
17116 | ||
17117 | DEFINITIONS ::= | |
17118 | BEGIN | |
17119 | BERPDU ::= REAL | |
17120 | b BERPDU ::= -12345678900.00 | |
17121 | ||
17122 | END | |
17123 | ||
17124 | <STATIC> | |
17125 | ||
17126 | import from TempA all; | |
17127 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17128 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17129 | ||
17130 | ||
17131 | ||
17132 | <TTCN_TC:EXEC> | |
17133 | ||
17134 | if ((enc_DER_PDU(b) == '090E032D3132333435363738392E4532'O)and(enc_CER_PDU(b) == '090E032D3132333435363738392E4532'O)) {setverdict(pass);} else {setverdict(fail);} | |
17135 | ||
17136 | <RESULT> | |
17137 | ||
17138 | Overall verdict: pass | |
17139 | ||
17140 | <END_TC> | |
17141 | ||
17142 | :exmp. | |
17143 | ||
17144 | .*---------------------------------------------------------------------* | |
17145 | :h3.CER + DER encoding of REAL, PLUS-INFINITY (primitive) | |
17146 | .*---------------------------------------------------------------------* | |
17147 | :xmp tab=0. | |
17148 | ||
17149 | <TC - CER + DER encoding of REAL, PLUS-INFINITY (primitive)> | |
17150 | ||
17151 | <STATIC:ASN> | |
17152 | ||
17153 | TempA | |
17154 | ||
17155 | DEFINITIONS ::= | |
17156 | BEGIN | |
17157 | BERPDU ::= REAL | |
17158 | b BERPDU ::= PLUS-INFINITY | |
17159 | ||
17160 | END | |
17161 | ||
17162 | <STATIC> | |
17163 | ||
17164 | import from TempA all; | |
17165 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17166 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17167 | ||
17168 | ||
17169 | ||
17170 | <TTCN_TC:EXEC> | |
17171 | ||
17172 | if ((enc_DER_PDU(b) == '090140'O)and(enc_CER_PDU(b) == '090140'O)) {setverdict(pass);} else {setverdict(fail);} | |
17173 | ||
17174 | <RESULT> | |
17175 | ||
17176 | Overall verdict: pass | |
17177 | ||
17178 | <END_TC> | |
17179 | ||
17180 | :exmp. | |
17181 | ||
17182 | .*---------------------------------------------------------------------* | |
17183 | :h3.CER + DER encoding of REAL, MINUS-INFINITY (primitive) | |
17184 | .*---------------------------------------------------------------------* | |
17185 | :xmp tab=0. | |
17186 | ||
17187 | <TC - CER + DER encoding of REAL, MINUS-INFINITY (primitive)> | |
17188 | ||
17189 | <STATIC:ASN> | |
17190 | ||
17191 | TempA | |
17192 | ||
17193 | DEFINITIONS ::= | |
17194 | BEGIN | |
17195 | BERPDU ::= REAL | |
17196 | b BERPDU ::= MINUS-INFINITY | |
17197 | ||
17198 | END | |
17199 | ||
17200 | <STATIC> | |
17201 | ||
17202 | import from TempA all; | |
17203 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17204 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17205 | ||
17206 | ||
17207 | ||
17208 | <TTCN_TC:EXEC> | |
17209 | ||
17210 | if ((enc_DER_PDU(b) == '090141'O)and(enc_CER_PDU(b) == '090141'O)) {setverdict(pass);} else {setverdict(fail);} | |
17211 | ||
17212 | <RESULT> | |
17213 | ||
17214 | Overall verdict: pass | |
17215 | ||
17216 | <END_TC> | |
17217 | ||
17218 | :exmp. | |
17219 | ||
17220 | .*---------------------------------------------------------------------* | |
17221 | :h3.CER + DER encoding of REAL, 1 , IMPICIT TAG | |
17222 | .*---------------------------------------------------------------------* | |
17223 | :xmp tab=0. | |
17224 | ||
17225 | <TC - CER + DER encoding of REAL, 1 , IMPICIT TAG> | |
17226 | ||
17227 | <STATIC:ASN> | |
17228 | ||
17229 | TempA | |
17230 | ||
17231 | DEFINITIONS ::= | |
17232 | BEGIN | |
17233 | BERPDU ::= [0] IMPLICIT REAL | |
17234 | b BERPDU ::= 1 | |
17235 | ||
17236 | END | |
17237 | ||
17238 | <STATIC> | |
17239 | ||
17240 | import from TempA all; | |
17241 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17242 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17243 | ||
17244 | ||
17245 | ||
17246 | <TTCN_TC:EXEC> | |
17247 | ||
17248 | if ((enc_DER_PDU(b) == '800603312E452B30'O)and(enc_CER_PDU(b) == '800603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
17249 | ||
17250 | <RESULT> | |
17251 | ||
17252 | Overall verdict: pass | |
17253 | ||
17254 | <END_TC> | |
17255 | ||
17256 | :exmp. | |
17257 | ||
17258 | .*---------------------------------------------------------------------* | |
17259 | :h3.CER + DER encoding of REAL, 1 , EXPICIT TAG | |
17260 | .*---------------------------------------------------------------------* | |
17261 | :xmp tab=0. | |
17262 | ||
17263 | <TC - CER + DER encoding of REAL, 1 , EXPICIT TAG> | |
17264 | ||
17265 | <STATIC:ASN> | |
17266 | ||
17267 | TempA | |
17268 | ||
17269 | DEFINITIONS ::= | |
17270 | BEGIN | |
17271 | BERPDU ::= [0] EXPLICIT REAL | |
17272 | b BERPDU ::= 1 | |
17273 | ||
17274 | END | |
17275 | ||
17276 | <STATIC> | |
17277 | ||
17278 | import from TempA all; | |
17279 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17280 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17281 | ||
17282 | ||
17283 | ||
17284 | <TTCN_TC:EXEC> | |
17285 | ||
17286 | if ((enc_DER_PDU(b) == 'A008090603312E452B30'O)and(enc_CER_PDU(b) == 'A080090603312E452B300000'O)) {setverdict(pass);} else {setverdict(fail);} | |
17287 | ||
17288 | <RESULT> | |
17289 | ||
17290 | Overall verdict: pass | |
17291 | ||
17292 | <END_TC> | |
17293 | ||
17294 | :exmp. | |
17295 | ||
17296 | .*---------------------------------------------------------------------* | |
17297 | :h3.CER + DER encoding of BIT STRING, length = 0 (primitive) | |
17298 | .*---------------------------------------------------------------------* | |
17299 | :xmp tab=0. | |
17300 | ||
17301 | <TC - CER + DER encoding of BIT STRING, length = 0 (primitive)> | |
17302 | ||
17303 | <STATIC:ASN> | |
17304 | ||
17305 | TempA | |
17306 | ||
17307 | DEFINITIONS ::= | |
17308 | BEGIN | |
17309 | BERPDU ::= BIT STRING | |
17310 | END | |
17311 | ||
17312 | <STATIC> | |
17313 | ||
17314 | import from TempA all; | |
17315 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17316 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17317 | ||
17318 | const BERPDU b := ''B | |
17319 | ||
17320 | <TTCN_TC:EXEC> | |
17321 | ||
17322 | if ((enc_DER_PDU(b) == '030100'O)and(enc_CER_PDU(b) == '030100'O)) {setverdict(pass);} else {setverdict(fail);} | |
17323 | ||
17324 | <RESULT> | |
17325 | ||
17326 | Overall verdict: pass | |
17327 | ||
17328 | <END_TC> | |
17329 | ||
17330 | :exmp. | |
17331 | ||
17332 | .*---------------------------------------------------------------------* | |
17333 | :h3.CER + DER encoding of BIT STRING, length = 1 (primitive) | |
17334 | .*---------------------------------------------------------------------* | |
17335 | :xmp tab=0. | |
17336 | ||
17337 | <TC - CER + DER encoding of BIT STRING, length = 1 (primitive)> | |
17338 | ||
17339 | <STATIC:ASN> | |
17340 | ||
17341 | TempA | |
17342 | ||
17343 | DEFINITIONS ::= | |
17344 | BEGIN | |
17345 | BERPDU ::= BIT STRING | |
17346 | END | |
17347 | ||
17348 | <STATIC> | |
17349 | ||
17350 | import from TempA all; | |
17351 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17352 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17353 | ||
17354 | const BERPDU b := '1'B | |
17355 | ||
17356 | <TTCN_TC:EXEC> | |
17357 | ||
17358 | if ((enc_DER_PDU(b) == '03020780'O)and(enc_CER_PDU(b) == '03020780'O)) {setverdict(pass);} else {setverdict(fail);} | |
17359 | ||
17360 | <RESULT> | |
17361 | ||
17362 | Overall verdict: pass | |
17363 | ||
17364 | <END_TC> | |
17365 | ||
17366 | :exmp. | |
17367 | ||
17368 | .*---------------------------------------------------------------------* | |
17369 | :h3.CER + DER encoding of BIT STRING, length = 7 (primitive) | |
17370 | .*---------------------------------------------------------------------* | |
17371 | :xmp tab=0. | |
17372 | ||
17373 | <TC - CER + DER encoding of BIT STRING, length = 7 (primitive)> | |
17374 | ||
17375 | <STATIC:ASN> | |
17376 | ||
17377 | TempA | |
17378 | ||
17379 | DEFINITIONS ::= | |
17380 | BEGIN | |
17381 | BERPDU ::= BIT STRING | |
17382 | END | |
17383 | ||
17384 | <STATIC> | |
17385 | ||
17386 | import from TempA all; | |
17387 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17388 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17389 | ||
17390 | const BERPDU b := '1010101'B | |
17391 | <TTCN_TC:EXEC> | |
17392 | ||
17393 | if ((enc_DER_PDU(b) == '030201AA'O)and(enc_CER_PDU(b) == '030201AA'O)) {setverdict(pass);} else {setverdict(fail);} | |
17394 | ||
17395 | <RESULT> | |
17396 | ||
17397 | Overall verdict: pass | |
17398 | ||
17399 | <END_TC> | |
17400 | ||
17401 | :exmp. | |
17402 | ||
17403 | .*---------------------------------------------------------------------* | |
17404 | :h3.CER + DER encoding of BIT STRING, length = 8 (primitive) | |
17405 | .*---------------------------------------------------------------------* | |
17406 | :xmp tab=0. | |
17407 | ||
17408 | <TC - CER + DER encoding of BIT STRING, length = 8 (primitive)> | |
17409 | ||
17410 | <STATIC:ASN> | |
17411 | ||
17412 | TempA | |
17413 | ||
17414 | DEFINITIONS ::= | |
17415 | BEGIN | |
17416 | BERPDU ::= BIT STRING | |
17417 | END | |
17418 | ||
17419 | <STATIC> | |
17420 | ||
17421 | import from TempA all; | |
17422 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17423 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17424 | ||
17425 | const BERPDU b := '10101010'B | |
17426 | <TTCN_TC:EXEC> | |
17427 | ||
17428 | if ((enc_DER_PDU(b) == '030200AA'O)and(enc_CER_PDU(b) == '030200AA'O)) {setverdict(pass);} else {setverdict(fail);} | |
17429 | ||
17430 | <RESULT> | |
17431 | ||
17432 | Overall verdict: pass | |
17433 | ||
17434 | <END_TC> | |
17435 | ||
17436 | :exmp. | |
17437 | ||
17438 | .*---------------------------------------------------------------------* | |
17439 | :h3.CER + DER encoding of BIT STRING, length = 9 (primitive) | |
17440 | .*---------------------------------------------------------------------* | |
17441 | :xmp tab=0. | |
17442 | ||
17443 | <TC - CER + DER encoding of BIT STRING, length = 9 (primitive)> | |
17444 | ||
17445 | <STATIC:ASN> | |
17446 | ||
17447 | TempA | |
17448 | ||
17449 | DEFINITIONS ::= | |
17450 | BEGIN | |
17451 | BERPDU ::= BIT STRING | |
17452 | END | |
17453 | ||
17454 | <STATIC> | |
17455 | ||
17456 | import from TempA all; | |
17457 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17458 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17459 | ||
17460 | const BERPDU b := '111100001'B | |
17461 | ||
17462 | <TTCN_TC:EXEC> | |
17463 | ||
17464 | if ((enc_DER_PDU(b) == '030307F080'O)and(enc_CER_PDU(b) == '030307F080'O)) {setverdict(pass);} else {setverdict(fail);} | |
17465 | ||
17466 | <RESULT> | |
17467 | ||
17468 | Overall verdict: pass | |
17469 | ||
17470 | <END_TC> | |
17471 | ||
17472 | :exmp. | |
17473 | ||
17474 | .*---------------------------------------------------------------------* | |
17475 | :h3.CER(primitive) + DER(primitive) encoding of BIT STRING, contents length = 1000 octets (999 octets of data and one unused bits octet) | |
17476 | .*---------------------------------------------------------------------* | |
17477 | :xmp tab=0. | |
17478 | ||
17479 | <TC - CER(primitive) + DER(primitive) encoding of BIT STRING, contents length = 1000 octets (999 octets of data and one unused bits octet)> | |
17480 | ||
17481 | <STATIC:ASN> | |
17482 | ||
17483 | TempA | |
17484 | ||
17485 | DEFINITIONS ::= | |
17486 | BEGIN | |
17487 | BERPDU ::= BIT STRING | |
17488 | ||
17489 | b BERPDU ::= 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
17490 | ||
17491 | ||
17492 | ||
17493 | END | |
17494 | ||
17495 | <STATIC> | |
17496 | ||
17497 | import from TempA all; | |
17498 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17499 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17500 | ||
17501 | <TTCN_TC:EXEC> | |
17502 | ||
17503 | if ((enc_DER_PDU(b) == '038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)and(enc_CER_PDU(b) == '038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)) {setverdict(pass);} else {setverdict(fail);} | |
17504 | ||
17505 | <RESULT> | |
17506 | ||
17507 | Overall verdict: pass | |
17508 | ||
17509 | <END_TC> | |
17510 | ||
17511 | :exmp. | |
17512 | ||
17513 | .*---------------------------------------------------------------------* | |
17514 | :h3.CER(constructed) + DER(primitive) encoding of BIT STRING, contents length = 1001 octets (1000 octets of data and one (ENC_02_014 and ENC_02_015) ENC_02_012 and ENC_02_012 | |
17515 | .*---------------------------------------------------------------------* | |
17516 | :xmp tab=0. | |
17517 | ||
17518 | <TC - CER(constructed) + DER(primitive) encoding of BIT STRING, contents length = 1001 octets (1000 octets of data and one (ENC_02_014 and ENC_02_015) ENC_02_012 and ENC_02_012> | |
17519 | ||
17520 | <STATIC:ASN> | |
17521 | ||
17522 | TempA | |
17523 | ||
17524 | DEFINITIONS ::= | |
17525 | BEGIN | |
17526 | BERPDU ::= BIT STRING | |
17527 | ||
17528 | b BERPDU ::= 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
17529 | ||
17530 | ||
17531 | END | |
17532 | ||
17533 | <STATIC> | |
17534 | ||
17535 | import from TempA all; | |
17536 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17537 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17538 | ||
17539 | ||
17540 | <TTCN_TC:EXEC> | |
17541 | ||
17542 | if ((enc_DER_PDU(b) == '038203E900FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)and(enc_CER_PDU(b) | |
17543 | == '2380038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF030200FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
17544 | ||
17545 | <RESULT> | |
17546 | ||
17547 | Overall verdict: pass | |
17548 | ||
17549 | <END_TC> | |
17550 | ||
17551 | :exmp. | |
17552 | ||
17553 | .*---------------------------------------------------------------------* | |
17554 | :h3.CER + DER encoding of BIT STRING, length = 1, IMPLICIT TAG (primitive) | |
17555 | .*---------------------------------------------------------------------* | |
17556 | :xmp tab=0. | |
17557 | ||
17558 | <TC - CER + DER encoding of BIT STRING, length = 1, IMPLICIT TAG (primitive)> | |
17559 | ||
17560 | <STATIC:ASN> | |
17561 | ||
17562 | TempA | |
17563 | ||
17564 | DEFINITIONS ::= | |
17565 | BEGIN | |
17566 | BERPDU ::= [0] IMPLICIT BIT STRING | |
17567 | END | |
17568 | ||
17569 | <STATIC> | |
17570 | ||
17571 | import from TempA all; | |
17572 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17573 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17574 | ||
17575 | const BERPDU b := '1'B | |
17576 | ||
17577 | <TTCN_TC:EXEC> | |
17578 | ||
17579 | if ((enc_DER_PDU(b) == '80020780'O)and(enc_CER_PDU(b) == '80020780'O)) {setverdict(pass);} else {setverdict(fail);} | |
17580 | ||
17581 | <RESULT> | |
17582 | ||
17583 | Overall verdict: pass | |
17584 | ||
17585 | <END_TC> | |
17586 | ||
17587 | :exmp. | |
17588 | ||
17589 | .*---------------------------------------------------------------------* | |
17590 | :h3.CER + DER encoding of BIT STRING, length = 1, EXPLICIT TAG (constructed) | |
17591 | .*---------------------------------------------------------------------* | |
17592 | :xmp tab=0. | |
17593 | ||
17594 | <TC - CER + DER encoding of BIT STRING, length = 1, EXPLICIT TAG (constructed)> | |
17595 | ||
17596 | <STATIC:ASN> | |
17597 | ||
17598 | TempA | |
17599 | ||
17600 | DEFINITIONS ::= | |
17601 | BEGIN | |
17602 | BERPDU ::= [0] EXPLICIT BIT STRING | |
17603 | END | |
17604 | ||
17605 | <STATIC> | |
17606 | ||
17607 | import from TempA all; | |
17608 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
17609 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
17610 | ||
17611 | const BERPDU b := '1'B | |
17612 | ||
17613 | <TTCN_TC:EXEC> | |
17614 | ||
17615 | if ((enc_DER_PDU(b) == 'A00403020780'O)and(enc_CER_PDU(b) == 'A080030207800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
17616 | ||
17617 | <RESULT> | |
17618 | ||
17619 | Overall verdict: pass | |
17620 | ||
17621 | <END_TC> | |
17622 | ||
17623 | :exmp. | |
17624 | ||
17625 | .*---------------------------------------------------------------------* | |
17626 | :h3. DECODING BIT STRING ,length = 0 ,CER +DER (primitive) | |
17627 | .*---------------------------------------------------------------------* | |
17628 | :xmp tab=0. | |
17629 | ||
17630 | <TC - DECODING BIT STRING ,length = 0 ,CER +DER (primitive)> | |
17631 | ||
17632 | <STATIC:ASN> | |
17633 | ||
17634 | TempA | |
17635 | ||
17636 | DEFINITIONS ::= | |
17637 | BEGIN | |
17638 | BERPDU ::= BIT STRING | |
17639 | ||
17640 | myValue BERPDU ::=''B | |
17641 | ||
17642 | END | |
17643 | ||
17644 | <STATIC> | |
17645 | ||
17646 | import from TempA all; | |
17647 | ||
17648 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
17649 | ||
17650 | ||
17651 | <TTCN_TC:EXEC> | |
17652 | ||
17653 | if (dec_BER_PDU('030100'O) == myValue) | |
17654 | ||
17655 | ||
17656 | {setverdict(pass);} else {setverdict(fail);} | |
17657 | ||
17658 | ||
17659 | <RESULT> | |
17660 | ||
17661 | Overall verdict: pass | |
17662 | ||
17663 | <END_TC> | |
17664 | ||
17665 | :exmp. | |
17666 | ||
17667 | .*---------------------------------------------------------------------* | |
17668 | :h3. DECODING BIT STRING ,length = 0 ,constructed | |
17669 | .*---------------------------------------------------------------------* | |
17670 | :xmp tab=0. | |
17671 | ||
17672 | <TC - DECODING BIT STRING ,length = 0 ,constructed> | |
17673 | ||
17674 | <STATIC:ASN> | |
17675 | ||
17676 | TempA | |
17677 | ||
17678 | DEFINITIONS ::= | |
17679 | BEGIN | |
17680 | BERPDU ::= BIT STRING | |
17681 | ||
17682 | myValue BERPDU ::=''B | |
17683 | ||
17684 | END | |
17685 | ||
17686 | <STATIC> | |
17687 | ||
17688 | import from TempA all; | |
17689 | ||
17690 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
17691 | ||
17692 | ||
17693 | <TTCN_TC:EXEC> | |
17694 | ||
17695 | if (dec_BER_PDU('2303030100'O) == myValue) | |
17696 | ||
17697 | ||
17698 | {setverdict(pass);} else {setverdict(fail);} | |
17699 | ||
17700 | ||
17701 | <RESULT> | |
17702 | ||
17703 | Overall verdict: pass | |
17704 | ||
17705 | <END_TC> | |
17706 | ||
17707 | :exmp. | |
17708 | ||
17709 | .*---------------------------------------------------------------------* | |
17710 | :h3. DECODING BIT STRING ,2xlength = 0 ,constructed | |
17711 | .*---------------------------------------------------------------------* | |
17712 | :xmp tab=0. | |
17713 | ||
17714 | <TC - DECODING BIT STRING ,2xlength = 0 ,constructed> | |
17715 | ||
17716 | <STATIC:ASN> | |
17717 | ||
17718 | TempA | |
17719 | ||
17720 | DEFINITIONS ::= | |
17721 | BEGIN | |
17722 | BERPDU ::= BIT STRING | |
17723 | ||
17724 | myValue BERPDU ::=''B | |
17725 | ||
17726 | END | |
17727 | ||
17728 | <STATIC> | |
17729 | ||
17730 | import from TempA all; | |
17731 | ||
17732 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
17733 | ||
17734 | ||
17735 | <TTCN_TC:EXEC> | |
17736 | ||
17737 | if (dec_BER_PDU('2306030100030100'O) == myValue) | |
17738 | ||
17739 | ||
17740 | {setverdict(pass);} else {setverdict(fail);} | |
17741 | ||
17742 | ||
17743 | <RESULT> | |
17744 | ||
17745 | Overall verdict: pass | |
17746 | ||
17747 | <END_TC> | |
17748 | ||
17749 | :exmp. | |
17750 | ||
17751 | .*---------------------------------------------------------------------* | |
17752 | :h3. DECODING BIT STRING ,length = 0 ,constructed, indefinite | |
17753 | .*---------------------------------------------------------------------* | |
17754 | :xmp tab=0. | |
17755 | ||
17756 | <TC - DECODING BIT STRING ,length = 0 ,constructed, indefinite> | |
17757 | ||
17758 | <STATIC:ASN> | |
17759 | ||
17760 | TempA | |
17761 | ||
17762 | DEFINITIONS ::= | |
17763 | BEGIN | |
17764 | BERPDU ::= BIT STRING | |
17765 | ||
17766 | myIntegerValue BERPDU ::=''B | |
17767 | ||
17768 | END | |
17769 | ||
17770 | <STATIC> | |
17771 | ||
17772 | import from TempA all; | |
17773 | ||
17774 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
17775 | ||
17776 | ||
17777 | <TTCN_TC:EXEC> | |
17778 | ||
17779 | if (dec_BER_PDU('23800301000000'O) == myIntegerValue) | |
17780 | ||
17781 | ||
17782 | {setverdict(pass);} else {setverdict(fail);} | |
17783 | ||
17784 | ||
17785 | <RESULT> | |
17786 | ||
17787 | Overall verdict: pass | |
17788 | ||
17789 | <END_TC> | |
17790 | ||
17791 | :exmp. | |
17792 | ||
17793 | .*---------------------------------------------------------------------* | |
17794 | :h3. DECODING BIT STRING ,length = 1 ,CER + DER, (primitive) | |
17795 | .*---------------------------------------------------------------------* | |
17796 | :xmp tab=0. | |
17797 | ||
17798 | <TC - DECODING BIT STRING ,length = 1 ,CER + DER, (primitive)> | |
17799 | ||
17800 | <STATIC:ASN> | |
17801 | ||
17802 | TempA | |
17803 | ||
17804 | DEFINITIONS ::= | |
17805 | BEGIN | |
17806 | BERPDU ::= BIT STRING | |
17807 | ||
17808 | myValue BERPDU ::='1'B | |
17809 | ||
17810 | END | |
17811 | ||
17812 | <STATIC> | |
17813 | ||
17814 | import from TempA all; | |
17815 | ||
17816 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
17817 | ||
17818 | ||
17819 | <TTCN_TC:EXEC> | |
17820 | ||
17821 | if (dec_BER_PDU('03020780'O) == myValue) | |
17822 | ||
17823 | ||
17824 | {setverdict(pass);} else {setverdict(fail);} | |
17825 | ||
17826 | ||
17827 | <RESULT> | |
17828 | ||
17829 | Overall verdict: pass | |
17830 | ||
17831 | <END_TC> | |
17832 | ||
17833 | :exmp. | |
17834 | ||
17835 | .*---------------------------------------------------------------------* | |
17836 | :h3. DECODING BIT STRING ,length = 1 , (primitive, long form) | |
17837 | .*---------------------------------------------------------------------* | |
17838 | :xmp tab=0. | |
17839 | ||
17840 | <TC - DECODING BIT STRING ,length = 1 , (primitive, long form)> | |
17841 | ||
17842 | <STATIC:ASN> | |
17843 | ||
17844 | TempA | |
17845 | ||
17846 | DEFINITIONS ::= | |
17847 | BEGIN | |
17848 | BERPDU ::= BIT STRING | |
17849 | ||
17850 | myIntegerValue BERPDU ::='1'B | |
17851 | ||
17852 | END | |
17853 | ||
17854 | <STATIC> | |
17855 | ||
17856 | import from TempA all; | |
17857 | ||
17858 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
17859 | ||
17860 | ||
17861 | <TTCN_TC:EXEC> | |
17862 | ||
17863 | if (dec_BER_PDU('0381020780'O) == myIntegerValue) | |
17864 | ||
17865 | ||
17866 | {setverdict(pass);} else {setverdict(fail);} | |
17867 | ||
17868 | ||
17869 | <RESULT> | |
17870 | ||
17871 | Overall verdict: pass | |
17872 | ||
17873 | <END_TC> | |
17874 | ||
17875 | :exmp. | |
17876 | ||
17877 | .*---------------------------------------------------------------------* | |
17878 | :h3. DECODING BIT STRING ,length = 1 , (constructed, short form - short form) | |
17879 | .*---------------------------------------------------------------------* | |
17880 | :xmp tab=0. | |
17881 | ||
17882 | <TC - DECODING BIT STRING ,length = 1 , (constructed, short form - short form)> | |
17883 | ||
17884 | <STATIC:ASN> | |
17885 | ||
17886 | TempA | |
17887 | ||
17888 | DEFINITIONS ::= | |
17889 | BEGIN | |
17890 | BERPDU ::= BIT STRING | |
17891 | ||
17892 | myValue BERPDU ::='1'B | |
17893 | ||
17894 | END | |
17895 | ||
17896 | <STATIC> | |
17897 | ||
17898 | import from TempA all; | |
17899 | ||
17900 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
17901 | ||
17902 | ||
17903 | <TTCN_TC:EXEC> | |
17904 | ||
17905 | if (dec_BER_PDU('230403020780'O) == myValue) | |
17906 | ||
17907 | ||
17908 | {setverdict(pass);} else {setverdict(fail);} | |
17909 | ||
17910 | ||
17911 | <RESULT> | |
17912 | ||
17913 | Overall verdict: pass | |
17914 | ||
17915 | <END_TC> | |
17916 | ||
17917 | :exmp. | |
17918 | ||
17919 | .*---------------------------------------------------------------------* | |
17920 | :h3. DECODING BIT STRING ,length = 1 , (constructed, short form - long form) | |
17921 | .*---------------------------------------------------------------------* | |
17922 | :xmp tab=0. | |
17923 | ||
17924 | <TC - DECODING BIT STRING ,length = 1 , (constructed, short form - long form)> | |
17925 | ||
17926 | <STATIC:ASN> | |
17927 | ||
17928 | TempA | |
17929 | ||
17930 | DEFINITIONS ::= | |
17931 | BEGIN | |
17932 | BERPDU ::= BIT STRING | |
17933 | ||
17934 | myValue BERPDU ::='1'B | |
17935 | ||
17936 | END | |
17937 | ||
17938 | <STATIC> | |
17939 | ||
17940 | import from TempA all; | |
17941 | ||
17942 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
17943 | ||
17944 | ||
17945 | <TTCN_TC:EXEC> | |
17946 | ||
17947 | if (dec_BER_PDU('23050381020780'O) == myValue) | |
17948 | ||
17949 | ||
17950 | {setverdict(pass);} else {setverdict(fail);} | |
17951 | ||
17952 | ||
17953 | <RESULT> | |
17954 | ||
17955 | Overall verdict: pass | |
17956 | ||
17957 | <END_TC> | |
17958 | ||
17959 | :exmp. | |
17960 | ||
17961 | .*---------------------------------------------------------------------* | |
17962 | :h3. DECODING BIT STRING ,length = 1 , (constructed, long form - long form) | |
17963 | .*---------------------------------------------------------------------* | |
17964 | :xmp tab=0. | |
17965 | ||
17966 | <TC - DECODING BIT STRING ,length = 1 , (constructed, long form - long form)> | |
17967 | ||
17968 | <STATIC:ASN> | |
17969 | ||
17970 | TempA | |
17971 | ||
17972 | DEFINITIONS ::= | |
17973 | BEGIN | |
17974 | BERPDU ::= BIT STRING | |
17975 | ||
17976 | myValue BERPDU ::='1'B | |
17977 | ||
17978 | END | |
17979 | ||
17980 | <STATIC> | |
17981 | ||
17982 | import from TempA all; | |
17983 | ||
17984 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
17985 | ||
17986 | ||
17987 | <TTCN_TC:EXEC> | |
17988 | ||
17989 | if (dec_BER_PDU('2381050381020780'O) == myValue) | |
17990 | ||
17991 | ||
17992 | {setverdict(pass);} else {setverdict(fail);} | |
17993 | ||
17994 | ||
17995 | <RESULT> | |
17996 | ||
17997 | Overall verdict: pass | |
17998 | ||
17999 | <END_TC> | |
18000 | ||
18001 | :exmp. | |
18002 | ||
18003 | .*---------------------------------------------------------------------* | |
18004 | :h3. DECODING BIT STRING ,length = 1 , (constructed, indefinite form) | |
18005 | .*---------------------------------------------------------------------* | |
18006 | :xmp tab=0. | |
18007 | ||
18008 | <TC - DECODING BIT STRING ,length = 1 , (constructed, indefinite form)> | |
18009 | ||
18010 | <STATIC:ASN> | |
18011 | ||
18012 | TempA | |
18013 | ||
18014 | DEFINITIONS ::= | |
18015 | BEGIN | |
18016 | BERPDU ::= BIT STRING | |
18017 | ||
18018 | myValue BERPDU ::='1'B | |
18019 | ||
18020 | END | |
18021 | ||
18022 | <STATIC> | |
18023 | ||
18024 | import from TempA all; | |
18025 | ||
18026 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18027 | ||
18028 | ||
18029 | <TTCN_TC:EXEC> | |
18030 | ||
18031 | if (dec_BER_PDU('238003810207800000'O) == myValue) | |
18032 | ||
18033 | ||
18034 | {setverdict(pass);} else {setverdict(fail);} | |
18035 | ||
18036 | ||
18037 | <RESULT> | |
18038 | ||
18039 | Overall verdict: pass | |
18040 | ||
18041 | <END_TC> | |
18042 | ||
18043 | :exmp. | |
18044 | ||
18045 | .*---------------------------------------------------------------------* | |
18046 | :h3. DECODING BIT STRING ,2xlength = 1 , (constructed, short form - short form) | |
18047 | .*---------------------------------------------------------------------* | |
18048 | :xmp tab=0. | |
18049 | ||
18050 | <TC - DECODING BIT STRING ,2xlength = 1 , (constructed, short form - short form)> | |
18051 | ||
18052 | <STATIC:ASN> | |
18053 | ||
18054 | TempA | |
18055 | ||
18056 | DEFINITIONS ::= | |
18057 | BEGIN | |
18058 | BERPDU ::= BIT STRING | |
18059 | ||
18060 | myValue BERPDU ::='11'B | |
18061 | ||
18062 | END | |
18063 | ||
18064 | <STATIC> | |
18065 | ||
18066 | import from TempA all; | |
18067 | ||
18068 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER:BER_ACCEPT_ALL)" } | |
18069 | ||
18070 | ||
18071 | <TTCN_TC:EXEC> | |
18072 | ||
18073 | if (dec_BER_PDU('23080302078003020780'O) == myValue) | |
18074 | ||
18075 | ||
18076 | {setverdict(pass);} else {setverdict(fail);} | |
18077 | ||
18078 | ||
18079 | <RESULT> | |
18080 | ||
18081 | Overall verdict: pass | |
18082 | ||
18083 | <END_TC> | |
18084 | ||
18085 | :exmp. | |
18086 | ||
18087 | .*---------------------------------------------------------------------* | |
18088 | :h3. DECODING BIT STRING ,2xlength = 1 , (constructed inside constructed) | |
18089 | .*---------------------------------------------------------------------* | |
18090 | :xmp tab=0. | |
18091 | ||
18092 | <TC - DECODING BIT STRING ,2xlength = 1 , (constructed inside constructed)> | |
18093 | ||
18094 | <STATIC:ASN> | |
18095 | ||
18096 | TempA | |
18097 | ||
18098 | DEFINITIONS ::= | |
18099 | BEGIN | |
18100 | BERPDU ::= BIT STRING | |
18101 | ||
18102 | myValue BERPDU ::='1'B | |
18103 | ||
18104 | END | |
18105 | ||
18106 | <STATIC> | |
18107 | ||
18108 | import from TempA all; | |
18109 | ||
18110 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18111 | ||
18112 | ||
18113 | <TTCN_TC:EXEC> | |
18114 | ||
18115 | if (dec_BER_PDU('2306230403020780'O) == myValue) | |
18116 | ||
18117 | ||
18118 | {setverdict(pass);} else {setverdict(fail);} | |
18119 | ||
18120 | ||
18121 | <RESULT> | |
18122 | ||
18123 | Overall verdict: pass | |
18124 | ||
18125 | <END_TC> | |
18126 | ||
18127 | :exmp. | |
18128 | ||
18129 | .*---------------------------------------------------------------------* | |
18130 | :h3. DECODING BIT STRING ,length = 7 ,CER + DER, (primitive) | |
18131 | .*---------------------------------------------------------------------* | |
18132 | :xmp tab=0. | |
18133 | ||
18134 | <TC - DECODING BIT STRING ,length = 7 ,CER + DER, (primitive)> | |
18135 | ||
18136 | <STATIC:ASN> | |
18137 | ||
18138 | TempA | |
18139 | ||
18140 | DEFINITIONS ::= | |
18141 | BEGIN | |
18142 | BERPDU ::= BIT STRING | |
18143 | ||
18144 | myValue BERPDU ::='1010101'B | |
18145 | ||
18146 | END | |
18147 | ||
18148 | <STATIC> | |
18149 | ||
18150 | import from TempA all; | |
18151 | ||
18152 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18153 | ||
18154 | ||
18155 | <TTCN_TC:EXEC> | |
18156 | ||
18157 | if (dec_BER_PDU('030201AA'O) == myValue) | |
18158 | ||
18159 | ||
18160 | {setverdict(pass);} else {setverdict(fail);} | |
18161 | ||
18162 | ||
18163 | <RESULT> | |
18164 | ||
18165 | Overall verdict: pass | |
18166 | ||
18167 | <END_TC> | |
18168 | ||
18169 | :exmp. | |
18170 | ||
18171 | .*---------------------------------------------------------------------* | |
18172 | :h3. DECODING BIT STRING ,length = 7 , (primitive, long form) | |
18173 | .*---------------------------------------------------------------------* | |
18174 | :xmp tab=0. | |
18175 | ||
18176 | <TC - DECODING BIT STRING ,length = 7 , (primitive, long form)> | |
18177 | ||
18178 | <STATIC:ASN> | |
18179 | ||
18180 | TempA | |
18181 | ||
18182 | DEFINITIONS ::= | |
18183 | BEGIN | |
18184 | BERPDU ::= BIT STRING | |
18185 | ||
18186 | myIntegerValue BERPDU ::='1010101'B | |
18187 | ||
18188 | END | |
18189 | ||
18190 | <STATIC> | |
18191 | ||
18192 | import from TempA all; | |
18193 | ||
18194 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18195 | ||
18196 | ||
18197 | <TTCN_TC:EXEC> | |
18198 | ||
18199 | if (dec_BER_PDU('03810201AA'O) == myIntegerValue) | |
18200 | ||
18201 | ||
18202 | {setverdict(pass);} else {setverdict(fail);} | |
18203 | ||
18204 | ||
18205 | <RESULT> | |
18206 | ||
18207 | Overall verdict: pass | |
18208 | ||
18209 | <END_TC> | |
18210 | ||
18211 | :exmp. | |
18212 | ||
18213 | .*---------------------------------------------------------------------* | |
18214 | :h3. DECODING BIT STRING ,length = 7 , (constructed, short form - short form) | |
18215 | .*---------------------------------------------------------------------* | |
18216 | :xmp tab=0. | |
18217 | ||
18218 | <TC - DECODING BIT STRING ,length = 7 , (constructed, short form - short form)> | |
18219 | ||
18220 | <STATIC:ASN> | |
18221 | ||
18222 | TempA | |
18223 | ||
18224 | DEFINITIONS ::= | |
18225 | BEGIN | |
18226 | BERPDU ::= BIT STRING | |
18227 | ||
18228 | myValue BERPDU ::='1010101'B | |
18229 | ||
18230 | END | |
18231 | ||
18232 | <STATIC> | |
18233 | ||
18234 | import from TempA all; | |
18235 | ||
18236 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18237 | ||
18238 | ||
18239 | <TTCN_TC:EXEC> | |
18240 | ||
18241 | if (dec_BER_PDU('2304030201AA'O) == myValue) | |
18242 | ||
18243 | ||
18244 | {setverdict(pass);} else {setverdict(fail);} | |
18245 | ||
18246 | ||
18247 | <RESULT> | |
18248 | ||
18249 | Overall verdict: pass | |
18250 | ||
18251 | <END_TC> | |
18252 | ||
18253 | :exmp. | |
18254 | ||
18255 | .*---------------------------------------------------------------------* | |
18256 | :h3. DECODING BIT STRING ,length = 7 , (constructed, short form - long form) | |
18257 | .*---------------------------------------------------------------------* | |
18258 | :xmp tab=0. | |
18259 | ||
18260 | <TC - DECODING BIT STRING ,length = 7 , (constructed, short form - long form)> | |
18261 | ||
18262 | <STATIC:ASN> | |
18263 | ||
18264 | TempA | |
18265 | ||
18266 | DEFINITIONS ::= | |
18267 | BEGIN | |
18268 | BERPDU ::= BIT STRING | |
18269 | ||
18270 | myValue BERPDU ::='1010101'B | |
18271 | ||
18272 | END | |
18273 | ||
18274 | <STATIC> | |
18275 | ||
18276 | import from TempA all; | |
18277 | ||
18278 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18279 | ||
18280 | ||
18281 | <TTCN_TC:EXEC> | |
18282 | ||
18283 | if (dec_BER_PDU('230503810201AA'O) == myValue) | |
18284 | ||
18285 | ||
18286 | {setverdict(pass);} else {setverdict(fail);} | |
18287 | ||
18288 | ||
18289 | <RESULT> | |
18290 | ||
18291 | Overall verdict: pass | |
18292 | ||
18293 | <END_TC> | |
18294 | ||
18295 | :exmp. | |
18296 | ||
18297 | .*---------------------------------------------------------------------* | |
18298 | :h3. DECODING BIT STRING ,length = 7 , (constructed, long form - long form) | |
18299 | .*---------------------------------------------------------------------* | |
18300 | :xmp tab=0. | |
18301 | ||
18302 | <TC - DECODING BIT STRING ,length = 7 , (constructed, long form - long form)> | |
18303 | ||
18304 | <STATIC:ASN> | |
18305 | ||
18306 | TempA | |
18307 | ||
18308 | DEFINITIONS ::= | |
18309 | BEGIN | |
18310 | BERPDU ::= BIT STRING | |
18311 | ||
18312 | myValue BERPDU ::='1010101'B | |
18313 | ||
18314 | END | |
18315 | ||
18316 | <STATIC> | |
18317 | ||
18318 | import from TempA all; | |
18319 | ||
18320 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18321 | ||
18322 | ||
18323 | <TTCN_TC:EXEC> | |
18324 | ||
18325 | if (dec_BER_PDU('23810503810201AA'O) == myValue) | |
18326 | ||
18327 | ||
18328 | {setverdict(pass);} else {setverdict(fail);} | |
18329 | ||
18330 | ||
18331 | <RESULT> | |
18332 | ||
18333 | Overall verdict: pass | |
18334 | ||
18335 | <END_TC> | |
18336 | ||
18337 | :exmp. | |
18338 | ||
18339 | .*---------------------------------------------------------------------* | |
18340 | :h3. DECODING BIT STRING ,length = 7 , (constructed, indefinite form) | |
18341 | .*---------------------------------------------------------------------* | |
18342 | :xmp tab=0. | |
18343 | ||
18344 | <TC - DECODING BIT STRING ,length = 7 , (constructed, indefinite form)> | |
18345 | ||
18346 | <STATIC:ASN> | |
18347 | ||
18348 | TempA | |
18349 | ||
18350 | DEFINITIONS ::= | |
18351 | BEGIN | |
18352 | BERPDU ::= BIT STRING | |
18353 | ||
18354 | myValue BERPDU ::='1010101'B | |
18355 | ||
18356 | END | |
18357 | ||
18358 | <STATIC> | |
18359 | ||
18360 | import from TempA all; | |
18361 | ||
18362 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18363 | ||
18364 | ||
18365 | <TTCN_TC:EXEC> | |
18366 | ||
18367 | if (dec_BER_PDU('238003810201AA0000'O) == myValue) | |
18368 | ||
18369 | ||
18370 | {setverdict(pass);} else {setverdict(fail);} | |
18371 | ||
18372 | ||
18373 | <RESULT> | |
18374 | ||
18375 | Overall verdict: pass | |
18376 | ||
18377 | <END_TC> | |
18378 | ||
18379 | :exmp. | |
18380 | ||
18381 | .*---------------------------------------------------------------------* | |
18382 | :h3. DECODING BIT STRING ,2xlength = 7 , (constructed, short form - short form) | |
18383 | .*---------------------------------------------------------------------* | |
18384 | :xmp tab=0. | |
18385 | ||
18386 | <TC - DECODING BIT STRING ,2xlength = 7 , (constructed, short form - short form)> | |
18387 | ||
18388 | <STATIC:ASN> | |
18389 | ||
18390 | TempA | |
18391 | ||
18392 | DEFINITIONS ::= | |
18393 | BEGIN | |
18394 | BERPDU ::= BIT STRING | |
18395 | ||
18396 | myValue BERPDU ::='10101011010101'B | |
18397 | ||
18398 | END | |
18399 | ||
18400 | <STATIC> | |
18401 | ||
18402 | import from TempA all; | |
18403 | ||
18404 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18405 | ||
18406 | ||
18407 | <TTCN_TC:EXEC> | |
18408 | ||
18409 | if (dec_BER_PDU('2308030201AA030201AA'O) == myValue) | |
18410 | ||
18411 | ||
18412 | {setverdict(pass);} else {setverdict(fail);} | |
18413 | ||
18414 | ||
18415 | <RESULT> | |
18416 | ||
18417 | Overall verdict: pass | |
18418 | ||
18419 | <END_TC> | |
18420 | ||
18421 | :exmp. | |
18422 | ||
18423 | .*---------------------------------------------------------------------* | |
18424 | :h3. DECODING BIT STRING ,2xlength = 7 , (constructed inside constructed) | |
18425 | .*---------------------------------------------------------------------* | |
18426 | :xmp tab=0. | |
18427 | ||
18428 | <TC - DECODING BIT STRING ,2xlength = 7 , (constructed inside constructed)> | |
18429 | ||
18430 | <STATIC:ASN> | |
18431 | ||
18432 | TempA | |
18433 | ||
18434 | DEFINITIONS ::= | |
18435 | BEGIN | |
18436 | BERPDU ::= BIT STRING | |
18437 | ||
18438 | myValue BERPDU ::='1010101'B | |
18439 | ||
18440 | END | |
18441 | ||
18442 | <STATIC> | |
18443 | ||
18444 | import from TempA all; | |
18445 | ||
18446 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18447 | ||
18448 | ||
18449 | <TTCN_TC:EXEC> | |
18450 | ||
18451 | if (dec_BER_PDU('23062304030201AA'O) == myValue) | |
18452 | ||
18453 | ||
18454 | {setverdict(pass);} else {setverdict(fail);} | |
18455 | ||
18456 | ||
18457 | <RESULT> | |
18458 | ||
18459 | Overall verdict: pass | |
18460 | ||
18461 | <END_TC> | |
18462 | ||
18463 | :exmp. | |
18464 | ||
18465 | .*---------------------------------------------------------------------* | |
18466 | :h3. DECODING BIT STRING ,length = 8 ,CER + DER, (primitive) | |
18467 | .*---------------------------------------------------------------------* | |
18468 | :xmp tab=0. | |
18469 | ||
18470 | <TC - DECODING BIT STRING ,length = 8 ,CER + DER, (primitive)> | |
18471 | ||
18472 | <STATIC:ASN> | |
18473 | ||
18474 | TempA | |
18475 | ||
18476 | DEFINITIONS ::= | |
18477 | BEGIN | |
18478 | BERPDU ::= BIT STRING | |
18479 | ||
18480 | myValue BERPDU ::='10101010'B | |
18481 | ||
18482 | END | |
18483 | ||
18484 | <STATIC> | |
18485 | ||
18486 | import from TempA all; | |
18487 | ||
18488 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18489 | ||
18490 | ||
18491 | <TTCN_TC:EXEC> | |
18492 | ||
18493 | if (dec_BER_PDU('030200AA'O) == myValue) | |
18494 | ||
18495 | ||
18496 | {setverdict(pass);} else {setverdict(fail);} | |
18497 | ||
18498 | ||
18499 | <RESULT> | |
18500 | ||
18501 | Overall verdict: pass | |
18502 | ||
18503 | <END_TC> | |
18504 | ||
18505 | :exmp. | |
18506 | ||
18507 | .*---------------------------------------------------------------------* | |
18508 | :h3. DECODING BIT STRING ,length = 8 , (primitive, long form) | |
18509 | .*---------------------------------------------------------------------* | |
18510 | :xmp tab=0. | |
18511 | ||
18512 | <TC - DECODING BIT STRING ,length = 8 , (primitive, long form)> | |
18513 | ||
18514 | <STATIC:ASN> | |
18515 | ||
18516 | TempA | |
18517 | ||
18518 | DEFINITIONS ::= | |
18519 | BEGIN | |
18520 | BERPDU ::= BIT STRING | |
18521 | ||
18522 | myIntegerValue BERPDU ::='10101010'B | |
18523 | ||
18524 | END | |
18525 | ||
18526 | <STATIC> | |
18527 | ||
18528 | import from TempA all; | |
18529 | ||
18530 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18531 | ||
18532 | ||
18533 | <TTCN_TC:EXEC> | |
18534 | ||
18535 | if (dec_BER_PDU('03810200AA'O) == myIntegerValue) | |
18536 | ||
18537 | ||
18538 | {setverdict(pass);} else {setverdict(fail);} | |
18539 | ||
18540 | ||
18541 | <RESULT> | |
18542 | ||
18543 | Overall verdict: pass | |
18544 | ||
18545 | <END_TC> | |
18546 | ||
18547 | :exmp. | |
18548 | ||
18549 | .*---------------------------------------------------------------------* | |
18550 | :h3. DECODING BIT STRING ,length = 8 , (constructed, short form - short form) | |
18551 | .*---------------------------------------------------------------------* | |
18552 | :xmp tab=0. | |
18553 | ||
18554 | <TC - DECODING BIT STRING ,length = 8 , (constructed, short form - short form)> | |
18555 | ||
18556 | <STATIC:ASN> | |
18557 | ||
18558 | TempA | |
18559 | ||
18560 | DEFINITIONS ::= | |
18561 | BEGIN | |
18562 | BERPDU ::= BIT STRING | |
18563 | ||
18564 | myValue BERPDU ::='10101010'B | |
18565 | ||
18566 | END | |
18567 | ||
18568 | <STATIC> | |
18569 | ||
18570 | import from TempA all; | |
18571 | ||
18572 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18573 | ||
18574 | ||
18575 | <TTCN_TC:EXEC> | |
18576 | ||
18577 | if (dec_BER_PDU('2304030200AA'O) == myValue) | |
18578 | ||
18579 | ||
18580 | {setverdict(pass);} else {setverdict(fail);} | |
18581 | ||
18582 | ||
18583 | <RESULT> | |
18584 | ||
18585 | Overall verdict: pass | |
18586 | ||
18587 | <END_TC> | |
18588 | ||
18589 | :exmp. | |
18590 | ||
18591 | .*---------------------------------------------------------------------* | |
18592 | :h3. DECODING BIT STRING ,length = 8 , (constructed, short form - long form) | |
18593 | .*---------------------------------------------------------------------* | |
18594 | :xmp tab=0. | |
18595 | ||
18596 | <TC - DECODING BIT STRING ,length = 8 , (constructed, short form - long form)> | |
18597 | ||
18598 | <STATIC:ASN> | |
18599 | ||
18600 | TempA | |
18601 | ||
18602 | DEFINITIONS ::= | |
18603 | BEGIN | |
18604 | BERPDU ::= BIT STRING | |
18605 | ||
18606 | myValue BERPDU ::='10101010'B | |
18607 | ||
18608 | END | |
18609 | ||
18610 | <STATIC> | |
18611 | ||
18612 | import from TempA all; | |
18613 | ||
18614 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18615 | ||
18616 | ||
18617 | <TTCN_TC:EXEC> | |
18618 | ||
18619 | if (dec_BER_PDU('230503810200AA'O) == myValue) | |
18620 | ||
18621 | ||
18622 | {setverdict(pass);} else {setverdict(fail);} | |
18623 | ||
18624 | ||
18625 | <RESULT> | |
18626 | ||
18627 | Overall verdict: pass | |
18628 | ||
18629 | <END_TC> | |
18630 | ||
18631 | :exmp. | |
18632 | ||
18633 | .*---------------------------------------------------------------------* | |
18634 | :h3. DECODING BIT STRING ,length = 8 , (constructed, long form - long form) | |
18635 | .*---------------------------------------------------------------------* | |
18636 | :xmp tab=0. | |
18637 | ||
18638 | <TC - DECODING BIT STRING ,length = 8 , (constructed, long form - long form)> | |
18639 | ||
18640 | <STATIC:ASN> | |
18641 | ||
18642 | TempA | |
18643 | ||
18644 | DEFINITIONS ::= | |
18645 | BEGIN | |
18646 | BERPDU ::= BIT STRING | |
18647 | ||
18648 | myValue BERPDU ::='10101010'B | |
18649 | ||
18650 | END | |
18651 | ||
18652 | <STATIC> | |
18653 | ||
18654 | import from TempA all; | |
18655 | ||
18656 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18657 | ||
18658 | ||
18659 | <TTCN_TC:EXEC> | |
18660 | ||
18661 | if (dec_BER_PDU('23810503810200AA'O) == myValue) | |
18662 | ||
18663 | ||
18664 | {setverdict(pass);} else {setverdict(fail);} | |
18665 | ||
18666 | ||
18667 | <RESULT> | |
18668 | ||
18669 | Overall verdict: pass | |
18670 | ||
18671 | <END_TC> | |
18672 | ||
18673 | :exmp. | |
18674 | ||
18675 | .*---------------------------------------------------------------------* | |
18676 | :h3. DECODING BIT STRING ,length = 8 , (constructed, indefinite form) | |
18677 | .*---------------------------------------------------------------------* | |
18678 | :xmp tab=0. | |
18679 | ||
18680 | <TC - DECODING BIT STRING ,length = 8 , (constructed, indefinite form)> | |
18681 | ||
18682 | <STATIC:ASN> | |
18683 | ||
18684 | TempA | |
18685 | ||
18686 | DEFINITIONS ::= | |
18687 | BEGIN | |
18688 | BERPDU ::= BIT STRING | |
18689 | ||
18690 | myValue BERPDU ::='10101010'B | |
18691 | ||
18692 | END | |
18693 | ||
18694 | <STATIC> | |
18695 | ||
18696 | import from TempA all; | |
18697 | ||
18698 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18699 | ||
18700 | ||
18701 | <TTCN_TC:EXEC> | |
18702 | ||
18703 | if (dec_BER_PDU('238003810200AA0000'O) == myValue) | |
18704 | ||
18705 | ||
18706 | {setverdict(pass);} else {setverdict(fail);} | |
18707 | ||
18708 | ||
18709 | <RESULT> | |
18710 | ||
18711 | Overall verdict: pass | |
18712 | ||
18713 | <END_TC> | |
18714 | ||
18715 | :exmp. | |
18716 | ||
18717 | .*---------------------------------------------------------------------* | |
18718 | :h3. DECODING BIT STRING ,2xlength = 8 , (constructed, short form - short form) | |
18719 | .*---------------------------------------------------------------------* | |
18720 | :xmp tab=0. | |
18721 | ||
18722 | <TC - DECODING BIT STRING ,2xlength = 8 , (constructed, short form - short form)> | |
18723 | ||
18724 | <STATIC:ASN> | |
18725 | ||
18726 | TempA | |
18727 | ||
18728 | DEFINITIONS ::= | |
18729 | BEGIN | |
18730 | BERPDU ::= BIT STRING | |
18731 | ||
18732 | myValue BERPDU ::='1010101010101010'B | |
18733 | ||
18734 | END | |
18735 | ||
18736 | <STATIC> | |
18737 | ||
18738 | import from TempA all; | |
18739 | ||
18740 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18741 | ||
18742 | ||
18743 | <TTCN_TC:EXEC> | |
18744 | ||
18745 | if (dec_BER_PDU('2308030200AA030200AA'O) == myValue) | |
18746 | ||
18747 | ||
18748 | {setverdict(pass);} else {setverdict(fail);} | |
18749 | ||
18750 | ||
18751 | <RESULT> | |
18752 | ||
18753 | Overall verdict: pass | |
18754 | ||
18755 | <END_TC> | |
18756 | ||
18757 | :exmp. | |
18758 | ||
18759 | .*---------------------------------------------------------------------* | |
18760 | :h3. DECODING BIT STRING ,2xlength = 8 , (constructed inside constructed) | |
18761 | .*---------------------------------------------------------------------* | |
18762 | :xmp tab=0. | |
18763 | ||
18764 | <TC - DECODING BIT STRING ,2xlength = 8 , (constructed inside constructed)> | |
18765 | ||
18766 | <STATIC:ASN> | |
18767 | ||
18768 | TempA | |
18769 | ||
18770 | DEFINITIONS ::= | |
18771 | BEGIN | |
18772 | BERPDU ::= BIT STRING | |
18773 | ||
18774 | myValue BERPDU ::='10101010'B | |
18775 | ||
18776 | END | |
18777 | ||
18778 | <STATIC> | |
18779 | ||
18780 | import from TempA all; | |
18781 | ||
18782 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18783 | ||
18784 | ||
18785 | <TTCN_TC:EXEC> | |
18786 | ||
18787 | if (dec_BER_PDU('23062304030200AA'O) == myValue) | |
18788 | ||
18789 | ||
18790 | {setverdict(pass);} else {setverdict(fail);} | |
18791 | ||
18792 | ||
18793 | <RESULT> | |
18794 | ||
18795 | Overall verdict: pass | |
18796 | ||
18797 | <END_TC> | |
18798 | ||
18799 | :exmp. | |
18800 | ||
18801 | .*---------------------------------------------------------------------* | |
18802 | :h3. DECODING BIT STRING ,length = 9 ,CER + DER, (primitive) | |
18803 | .*---------------------------------------------------------------------* | |
18804 | :xmp tab=0. | |
18805 | ||
18806 | <TC - DECODING BIT STRING ,length = 9 ,CER + DER, (primitive)> | |
18807 | ||
18808 | <STATIC:ASN> | |
18809 | ||
18810 | TempA | |
18811 | ||
18812 | DEFINITIONS ::= | |
18813 | BEGIN | |
18814 | BERPDU ::= BIT STRING | |
18815 | ||
18816 | myValue BERPDU ::='111100001'B | |
18817 | ||
18818 | END | |
18819 | ||
18820 | <STATIC> | |
18821 | ||
18822 | import from TempA all; | |
18823 | ||
18824 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18825 | ||
18826 | ||
18827 | <TTCN_TC:EXEC> | |
18828 | ||
18829 | if (dec_BER_PDU( '030307F080'O) == myValue) | |
18830 | ||
18831 | ||
18832 | {setverdict(pass);} else {setverdict(fail);} | |
18833 | ||
18834 | ||
18835 | <RESULT> | |
18836 | ||
18837 | Overall verdict: pass | |
18838 | ||
18839 | <END_TC> | |
18840 | ||
18841 | :exmp. | |
18842 | ||
18843 | .*---------------------------------------------------------------------* | |
18844 | :h3. DECODING BIT STRING ,length = 9 , (primitive, long form) | |
18845 | .*---------------------------------------------------------------------* | |
18846 | :xmp tab=0. | |
18847 | ||
18848 | <TC - DECODING BIT STRING ,length = 9 , (primitive, long form)> | |
18849 | ||
18850 | <STATIC:ASN> | |
18851 | ||
18852 | TempA | |
18853 | ||
18854 | DEFINITIONS ::= | |
18855 | BEGIN | |
18856 | BERPDU ::= BIT STRING | |
18857 | ||
18858 | myIntegerValue BERPDU ::='111100001'B | |
18859 | ||
18860 | END | |
18861 | ||
18862 | <STATIC> | |
18863 | ||
18864 | import from TempA all; | |
18865 | ||
18866 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18867 | ||
18868 | ||
18869 | <TTCN_TC:EXEC> | |
18870 | ||
18871 | if (dec_BER_PDU('03810307F080'O) == myIntegerValue) | |
18872 | ||
18873 | ||
18874 | {setverdict(pass);} else {setverdict(fail);} | |
18875 | ||
18876 | ||
18877 | <RESULT> | |
18878 | ||
18879 | Overall verdict: pass | |
18880 | ||
18881 | <END_TC> | |
18882 | ||
18883 | :exmp. | |
18884 | ||
18885 | .*---------------------------------------------------------------------* | |
18886 | :h3. DECODING BIT STRING ,length = 9 , (constructed, short form - short form) | |
18887 | .*---------------------------------------------------------------------* | |
18888 | :xmp tab=0. | |
18889 | ||
18890 | <TC - DECODING BIT STRING ,length = 9 , (constructed, short form - short form)> | |
18891 | ||
18892 | <STATIC:ASN> | |
18893 | ||
18894 | TempA | |
18895 | ||
18896 | DEFINITIONS ::= | |
18897 | BEGIN | |
18898 | BERPDU ::= BIT STRING | |
18899 | ||
18900 | myValue BERPDU ::='111100001'B | |
18901 | ||
18902 | END | |
18903 | ||
18904 | <STATIC> | |
18905 | ||
18906 | import from TempA all; | |
18907 | ||
18908 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18909 | ||
18910 | ||
18911 | <TTCN_TC:EXEC> | |
18912 | ||
18913 | if (dec_BER_PDU('2305030307F080'O) == myValue) | |
18914 | ||
18915 | ||
18916 | {setverdict(pass);} else {setverdict(fail);} | |
18917 | ||
18918 | ||
18919 | <RESULT> | |
18920 | ||
18921 | Overall verdict: pass | |
18922 | ||
18923 | <END_TC> | |
18924 | ||
18925 | :exmp. | |
18926 | ||
18927 | .*---------------------------------------------------------------------* | |
18928 | :h3. DECODING BIT STRING ,length = 9 , (constructed, short form - long form) | |
18929 | .*---------------------------------------------------------------------* | |
18930 | :xmp tab=0. | |
18931 | ||
18932 | <TC - DECODING BIT STRING ,length = 9 , (constructed, short form - long form)> | |
18933 | ||
18934 | <STATIC:ASN> | |
18935 | ||
18936 | TempA | |
18937 | ||
18938 | DEFINITIONS ::= | |
18939 | BEGIN | |
18940 | BERPDU ::= BIT STRING | |
18941 | ||
18942 | myValue BERPDU ::='111100001'B | |
18943 | ||
18944 | END | |
18945 | ||
18946 | <STATIC> | |
18947 | ||
18948 | import from TempA all; | |
18949 | ||
18950 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18951 | ||
18952 | ||
18953 | <TTCN_TC:EXEC> | |
18954 | ||
18955 | if (dec_BER_PDU('230603810307F080'O) == myValue) | |
18956 | ||
18957 | ||
18958 | {setverdict(pass);} else {setverdict(fail);} | |
18959 | ||
18960 | ||
18961 | <RESULT> | |
18962 | ||
18963 | Overall verdict: pass | |
18964 | ||
18965 | <END_TC> | |
18966 | ||
18967 | :exmp. | |
18968 | ||
18969 | .*---------------------------------------------------------------------* | |
18970 | :h3. DECODING BIT STRING ,length = 9 , (constructed, long form - long form) | |
18971 | .*---------------------------------------------------------------------* | |
18972 | :xmp tab=0. | |
18973 | ||
18974 | <TC - DECODING BIT STRING ,length = 9 , (constructed, long form - long form)> | |
18975 | ||
18976 | <STATIC:ASN> | |
18977 | ||
18978 | TempA | |
18979 | ||
18980 | DEFINITIONS ::= | |
18981 | BEGIN | |
18982 | BERPDU ::= BIT STRING | |
18983 | ||
18984 | myValue BERPDU ::='111100001'B | |
18985 | ||
18986 | END | |
18987 | ||
18988 | <STATIC> | |
18989 | ||
18990 | import from TempA all; | |
18991 | ||
18992 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
18993 | ||
18994 | ||
18995 | <TTCN_TC:EXEC> | |
18996 | ||
18997 | if (dec_BER_PDU('23810603810307F080'O) == myValue) | |
18998 | ||
18999 | ||
19000 | {setverdict(pass);} else {setverdict(fail);} | |
19001 | ||
19002 | ||
19003 | <RESULT> | |
19004 | ||
19005 | Overall verdict: pass | |
19006 | ||
19007 | <END_TC> | |
19008 | ||
19009 | :exmp. | |
19010 | ||
19011 | .*---------------------------------------------------------------------* | |
19012 | :h3. DECODING BIT STRING ,length = 9 , (constructed, indefinite form) | |
19013 | .*---------------------------------------------------------------------* | |
19014 | :xmp tab=0. | |
19015 | ||
19016 | <TC - DECODING BIT STRING ,length = 9 , (constructed, indefinite form)> | |
19017 | ||
19018 | <STATIC:ASN> | |
19019 | ||
19020 | TempA | |
19021 | ||
19022 | DEFINITIONS ::= | |
19023 | BEGIN | |
19024 | BERPDU ::= BIT STRING | |
19025 | ||
19026 | myValue BERPDU ::='111100001'B | |
19027 | ||
19028 | END | |
19029 | ||
19030 | <STATIC> | |
19031 | ||
19032 | import from TempA all; | |
19033 | ||
19034 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19035 | ||
19036 | ||
19037 | <TTCN_TC:EXEC> | |
19038 | ||
19039 | if (dec_BER_PDU('238003810307F0800000'O) == myValue) | |
19040 | ||
19041 | ||
19042 | {setverdict(pass);} else {setverdict(fail);} | |
19043 | ||
19044 | ||
19045 | <RESULT> | |
19046 | ||
19047 | Overall verdict: pass | |
19048 | ||
19049 | <END_TC> | |
19050 | ||
19051 | :exmp. | |
19052 | ||
19053 | .*---------------------------------------------------------------------* | |
19054 | :h3. DECODING BIT STRING ,2xlength = 9 , (constructed, short form - short form) | |
19055 | .*---------------------------------------------------------------------* | |
19056 | :xmp tab=0. | |
19057 | ||
19058 | <TC - DECODING BIT STRING ,2xlength = 9 , (constructed, short form - short form)> | |
19059 | ||
19060 | <STATIC:ASN> | |
19061 | ||
19062 | TempA | |
19063 | ||
19064 | DEFINITIONS ::= | |
19065 | BEGIN | |
19066 | BERPDU ::= BIT STRING | |
19067 | ||
19068 | myValue BERPDU ::='111100001111100001'B | |
19069 | ||
19070 | END | |
19071 | ||
19072 | <STATIC> | |
19073 | ||
19074 | import from TempA all; | |
19075 | ||
19076 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19077 | ||
19078 | ||
19079 | <TTCN_TC:EXEC> | |
19080 | ||
19081 | if (dec_BER_PDU('230A030307F080030307F080'O) == myValue) | |
19082 | ||
19083 | ||
19084 | {setverdict(pass);} else {setverdict(fail);} | |
19085 | ||
19086 | ||
19087 | <RESULT> | |
19088 | ||
19089 | Overall verdict: pass | |
19090 | ||
19091 | <END_TC> | |
19092 | ||
19093 | :exmp. | |
19094 | ||
19095 | .*---------------------------------------------------------------------* | |
19096 | :h3. DECODING BIT STRING ,length = 9 , (constructed inside constructed) | |
19097 | .*---------------------------------------------------------------------* | |
19098 | :xmp tab=0. | |
19099 | ||
19100 | <TC - DECODING BIT STRING ,length = 9 , (constructed inside constructed)> | |
19101 | ||
19102 | <STATIC:ASN> | |
19103 | ||
19104 | TempA | |
19105 | ||
19106 | DEFINITIONS ::= | |
19107 | BEGIN | |
19108 | BERPDU ::= BIT STRING | |
19109 | ||
19110 | myValue BERPDU ::='111100001'B | |
19111 | ||
19112 | END | |
19113 | ||
19114 | <STATIC> | |
19115 | ||
19116 | import from TempA all; | |
19117 | ||
19118 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19119 | ||
19120 | ||
19121 | <TTCN_TC:EXEC> | |
19122 | ||
19123 | if (dec_BER_PDU('23072305030307F080'O) == myValue) | |
19124 | ||
19125 | ||
19126 | {setverdict(pass);} else {setverdict(fail);} | |
19127 | ||
19128 | ||
19129 | <RESULT> | |
19130 | ||
19131 | Overall verdict: pass | |
19132 | ||
19133 | <END_TC> | |
19134 | ||
19135 | :exmp. | |
19136 | ||
19137 | .*---------------------------------------------------------------------* | |
19138 | :h3. DECODING BIT STRING ,length = 1000 CER + DER, primitive (999 octets of data and one unused bits octet) | |
19139 | .*---------------------------------------------------------------------* | |
19140 | :xmp tab=0. | |
19141 | ||
19142 | <TC - DECODING BIT STRING ,length = 1000 CER + DER, primitive (999 octets of data and one unused bits octet)> | |
19143 | ||
19144 | <STATIC:ASN> | |
19145 | ||
19146 | TempA | |
19147 | ||
19148 | DEFINITIONS ::= | |
19149 | BEGIN | |
19150 | BERPDU ::= BIT STRING | |
19151 | ||
19152 | myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
19153 | ||
19154 | END | |
19155 | ||
19156 | <STATIC> | |
19157 | ||
19158 | import from TempA all; | |
19159 | ||
19160 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19161 | ||
19162 | ||
19163 | <TTCN_TC:EXEC> | |
19164 | ||
19165 | if (dec_BER_PDU('038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue) | |
19166 | ||
19167 | ||
19168 | {setverdict(pass);} else {setverdict(fail);} | |
19169 | ||
19170 | ||
19171 | <RESULT> | |
19172 | ||
19173 | Overall verdict: pass | |
19174 | ||
19175 | <END_TC> | |
19176 | ||
19177 | :exmp. | |
19178 | ||
19179 | .*---------------------------------------------------------------------* | |
19180 | :h3. DECODING BIT STRING ,length = 1000 , primitive longer form (999 octets of data and one unused bits octet) | |
19181 | .*---------------------------------------------------------------------* | |
19182 | :xmp tab=0. | |
19183 | ||
19184 | <TC - DECODING BIT STRING ,length = 1000 , primitive longer form (999 octets of data and one unused bits octet)> | |
19185 | ||
19186 | <STATIC:ASN> | |
19187 | ||
19188 | TempA | |
19189 | ||
19190 | DEFINITIONS ::= | |
19191 | BEGIN | |
19192 | BERPDU ::= BIT STRING | |
19193 | ||
19194 | myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
19195 | ||
19196 | END | |
19197 | ||
19198 | <STATIC> | |
19199 | ||
19200 | import from TempA all; | |
19201 | ||
19202 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19203 | ||
19204 | ||
19205 | <TTCN_TC:EXEC> | |
19206 | ||
19207 | if (dec_BER_PDU('03830003E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue) | |
19208 | ||
19209 | ||
19210 | {setverdict(pass);} else {setverdict(fail);} | |
19211 | ||
19212 | ||
19213 | <RESULT> | |
19214 | ||
19215 | Overall verdict: pass | |
19216 | ||
19217 | <END_TC> | |
19218 | ||
19219 | :exmp. | |
19220 | ||
19221 | .*---------------------------------------------------------------------* | |
19222 | :h3. DECODING BIT STRING ,length = 1000 , constructed long form -long form (999 octets of data and one unused bits octet) | |
19223 | .*---------------------------------------------------------------------* | |
19224 | :xmp tab=0. | |
19225 | ||
19226 | <TC - DECODING BIT STRING ,length = 1000 , constructed long form -long form (999 octets of data and one unused bits octet)> | |
19227 | ||
19228 | <STATIC:ASN> | |
19229 | ||
19230 | TempA | |
19231 | ||
19232 | DEFINITIONS ::= | |
19233 | BEGIN | |
19234 | BERPDU ::= BIT STRING | |
19235 | ||
19236 | myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
19237 | ||
19238 | END | |
19239 | ||
19240 | <STATIC> | |
19241 | ||
19242 | import from TempA all; | |
19243 | ||
19244 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19245 | ||
19246 | ||
19247 | <TTCN_TC:EXEC> | |
19248 | ||
19249 | if (dec_BER_PDU('238203EC038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue) | |
19250 | ||
19251 | ||
19252 | {setverdict(pass);} else {setverdict(fail);} | |
19253 | ||
19254 | ||
19255 | <RESULT> | |
19256 | ||
19257 | Overall verdict: pass | |
19258 | ||
19259 | <END_TC> | |
19260 | ||
19261 | :exmp. | |
19262 | ||
19263 | .*---------------------------------------------------------------------* | |
19264 | :h3. DECODING BIT STRING ,length = 1000 , constructed indefinite form (999 octets of data and one unused bits octet) | |
19265 | .*---------------------------------------------------------------------* | |
19266 | :xmp tab=0. | |
19267 | ||
19268 | <TC - DECODING BIT STRING ,length = 1000 , constructed indefinite form (999 octets of data and one unused bits octet)> | |
19269 | ||
19270 | <STATIC:ASN> | |
19271 | ||
19272 | TempA | |
19273 | ||
19274 | DEFINITIONS ::= | |
19275 | BEGIN | |
19276 | BERPDU ::= BIT STRING | |
19277 | ||
19278 | myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
19279 | ||
19280 | END | |
19281 | ||
19282 | <STATIC> | |
19283 | ||
19284 | import from TempA all; | |
19285 | ||
19286 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19287 | ||
19288 | ||
19289 | <TTCN_TC:EXEC> | |
19290 | ||
19291 | if (dec_BER_PDU('2380038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000'O) == myValue) | |
19292 | ||
19293 | ||
19294 | {setverdict(pass);} else {setverdict(fail);} | |
19295 | ||
19296 | ||
19297 | <RESULT> | |
19298 | ||
19299 | Overall verdict: pass | |
19300 | ||
19301 | <END_TC> | |
19302 | ||
19303 | :exmp. | |
19304 | ||
19305 | .*---------------------------------------------------------------------* | |
19306 | :h3. DECODING BIT STRING ,2xlength = 1000 , constructed (999 octets of data and one unused bits octet) | |
19307 | .*---------------------------------------------------------------------* | |
19308 | :xmp tab=0. | |
19309 | ||
19310 | <TC - DECODING BIT STRING ,2xlength = 1000 , constructed (999 octets of data and one unused bits octet)> | |
19311 | ||
19312 | <STATIC:ASN> | |
19313 | ||
19314 | TempA | |
19315 | ||
19316 | DEFINITIONS ::= | |
19317 | BEGIN | |
19318 | BERPDU ::= BIT STRING | |
19319 | ||
19320 | myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
19321 | ||
19322 | END | |
19323 | ||
19324 | <STATIC> | |
19325 | ||
19326 | import from TempA all; | |
19327 | ||
19328 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19329 | ||
19330 | ||
19331 | <TTCN_TC:EXEC> | |
19332 | ||
19333 | if (dec_BER_PDU('238207D8038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue) | |
19334 | ||
19335 | ||
19336 | {setverdict(pass);} else {setverdict(fail);} | |
19337 | ||
19338 | ||
19339 | <RESULT> | |
19340 | ||
19341 | Overall verdict: pass | |
19342 | ||
19343 | <END_TC> | |
19344 | ||
19345 | :exmp. | |
19346 | ||
19347 | .*---------------------------------------------------------------------* | |
19348 | :h3. DECODING BIT STRING ,length = 1001 DER , primitive (1000 octets of data and one unused bits octet) | |
19349 | .*---------------------------------------------------------------------* | |
19350 | :xmp tab=0. | |
19351 | ||
19352 | <TC - DECODING BIT STRING ,length = 1001 DER , primitive (1000 octets of data and one unused bits octet)> | |
19353 | ||
19354 | <STATIC:ASN> | |
19355 | ||
19356 | TempA | |
19357 | ||
19358 | DEFINITIONS ::= | |
19359 | BEGIN | |
19360 | BERPDU ::= BIT STRING | |
19361 | ||
19362 | myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
19363 | ||
19364 | END | |
19365 | ||
19366 | <STATIC> | |
19367 | ||
19368 | import from TempA all; | |
19369 | ||
19370 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19371 | ||
19372 | ||
19373 | <TTCN_TC:EXEC> | |
19374 | ||
19375 | if (dec_BER_PDU('038203E900FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue) | |
19376 | ||
19377 | ||
19378 | {setverdict(pass);} else {setverdict(fail);} | |
19379 | ||
19380 | ||
19381 | <RESULT> | |
19382 | ||
19383 | Overall verdict: pass | |
19384 | ||
19385 | <END_TC> | |
19386 | ||
19387 | :exmp. | |
19388 | ||
19389 | .*---------------------------------------------------------------------* | |
19390 | :h3. DECODING BIT STRING ,length = 1001 CER , constructed (1000 octets of data and one unused bits octet) | |
19391 | .*---------------------------------------------------------------------* | |
19392 | :xmp tab=0. | |
19393 | ||
19394 | <TC - DECODING BIT STRING ,length = 1001 CER , constructed (1000 octets of data and one unused bits octet)> | |
19395 | ||
19396 | <STATIC:ASN> | |
19397 | ||
19398 | TempA | |
19399 | ||
19400 | DEFINITIONS ::= | |
19401 | BEGIN | |
19402 | BERPDU ::= BIT STRING | |
19403 | ||
19404 | myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
19405 | ||
19406 | END | |
19407 | ||
19408 | <STATIC> | |
19409 | ||
19410 | import from TempA all; | |
19411 | ||
19412 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19413 | ||
19414 | ||
19415 | <TTCN_TC:EXEC> | |
19416 | ||
19417 | if (dec_BER_PDU('238203F0038203E800FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF030200FF'O) == myValue) | |
19418 | ||
19419 | ||
19420 | {setverdict(pass);} else {setverdict(fail);} | |
19421 | ||
19422 | ||
19423 | <RESULT> | |
19424 | ||
19425 | Overall verdict: pass | |
19426 | ||
19427 | <END_TC> | |
19428 | ||
19429 | :exmp. | |
19430 | ||
19431 | .*---------------------------------------------------------------------* | |
19432 | :h3. DECODING BIT STRING ,length = 1001 , constructed (1000 octets of data and one unused bits octet) | |
19433 | .*---------------------------------------------------------------------* | |
19434 | :xmp tab=0. | |
19435 | ||
19436 | <TC - DECODING BIT STRING ,length = 1001 , constructed (1000 octets of data and one unused bits octet)> | |
19437 | ||
19438 | <STATIC:ASN> | |
19439 | ||
19440 | TempA | |
19441 | ||
19442 | DEFINITIONS ::= | |
19443 | BEGIN | |
19444 | BERPDU ::= BIT STRING | |
19445 | ||
19446 | myValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
19447 | ||
19448 | END | |
19449 | ||
19450 | <STATIC> | |
19451 | ||
19452 | import from TempA all; | |
19453 | ||
19454 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19455 | ||
19456 | ||
19457 | <TTCN_TC:EXEC> | |
19458 | ||
19459 | if (dec_BER_PDU('238203ED038203E900FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myValue) | |
19460 | ||
19461 | ||
19462 | {setverdict(pass);} else {setverdict(fail);} | |
19463 | ||
19464 | ||
19465 | <RESULT> | |
19466 | ||
19467 | Overall verdict: pass | |
19468 | ||
19469 | <END_TC> | |
19470 | ||
19471 | :exmp. | |
19472 | ||
19473 | .*---------------------------------------------------------------------* | |
19474 | :h3. DECODING BIT STRING CER +DER ,length = 1 , IMPLICIT TAG primitive | |
19475 | .*---------------------------------------------------------------------* | |
19476 | :xmp tab=0. | |
19477 | ||
19478 | <TC - DECODING BIT STRING CER +DER ,length = 1 , IMPLICIT TAG primitive > | |
19479 | ||
19480 | <STATIC:ASN> | |
19481 | ||
19482 | TempA | |
19483 | ||
19484 | DEFINITIONS ::= | |
19485 | BEGIN | |
19486 | BERPDU ::= [0] IMPLICIT BIT STRING | |
19487 | ||
19488 | myValue BERPDU ::='1'B | |
19489 | ||
19490 | END | |
19491 | ||
19492 | <STATIC> | |
19493 | ||
19494 | import from TempA all; | |
19495 | ||
19496 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19497 | ||
19498 | ||
19499 | <TTCN_TC:EXEC> | |
19500 | ||
19501 | if (dec_BER_PDU('80020780'O) == myValue) | |
19502 | ||
19503 | ||
19504 | {setverdict(pass);} else {setverdict(fail);} | |
19505 | ||
19506 | ||
19507 | <RESULT> | |
19508 | ||
19509 | Overall verdict: pass | |
19510 | ||
19511 | <END_TC> | |
19512 | ||
19513 | :exmp. | |
19514 | ||
19515 | .*---------------------------------------------------------------------* | |
19516 | :h3. DECODING BIT STRING CER ,length = 1 , EXPLICIT TAG (constructed ) | |
19517 | .*---------------------------------------------------------------------* | |
19518 | :xmp tab=0. | |
19519 | ||
19520 | <TC - DECODING BIT STRING CER ,length = 1 , EXPLICIT TAG (constructed )> | |
19521 | ||
19522 | <STATIC:ASN> | |
19523 | ||
19524 | TempA | |
19525 | ||
19526 | DEFINITIONS ::= | |
19527 | BEGIN | |
19528 | BERPDU ::= BIT STRING | |
19529 | ||
19530 | myValue BERPDU ::='1'B | |
19531 | ||
19532 | END | |
19533 | ||
19534 | <STATIC> | |
19535 | ||
19536 | import from TempA all; | |
19537 | ||
19538 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19539 | ||
19540 | ||
19541 | <TTCN_TC:EXEC> | |
19542 | ||
19543 | if (dec_BER_PDU('A080030207800000'O) == myValue) | |
19544 | ||
19545 | ||
19546 | {setverdict(pass);} else {setverdict(fail);} | |
19547 | ||
19548 | ||
19549 | <RESULT> | |
19550 | ||
19551 | Overall verdict: pass | |
19552 | ||
19553 | <END_TC> | |
19554 | ||
19555 | :exmp. | |
19556 | ||
19557 | .*---------------------------------------------------------------------* | |
19558 | :h3. DECODING BIT STRING DER ,length = 1 EXPLICIT TAG , (constructed ) | |
19559 | .*---------------------------------------------------------------------* | |
19560 | :xmp tab=0. | |
19561 | ||
19562 | <TC - DECODING BIT STRING DER ,length = 1 EXPLICIT TAG , (constructed )> | |
19563 | ||
19564 | <STATIC:ASN> | |
19565 | ||
19566 | TempA | |
19567 | ||
19568 | DEFINITIONS ::= | |
19569 | BEGIN | |
19570 | BERPDU ::= BIT STRING | |
19571 | ||
19572 | myValue BERPDU ::='1'B | |
19573 | ||
19574 | END | |
19575 | ||
19576 | <STATIC> | |
19577 | ||
19578 | import from TempA all; | |
19579 | ||
19580 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19581 | ||
19582 | ||
19583 | <TTCN_TC:EXEC> | |
19584 | ||
19585 | if (dec_BER_PDU('A00403020780'O) == myValue) | |
19586 | ||
19587 | ||
19588 | {setverdict(pass);} else {setverdict(fail);} | |
19589 | ||
19590 | ||
19591 | <RESULT> | |
19592 | ||
19593 | Overall verdict: pass | |
19594 | ||
19595 | <END_TC> | |
19596 | ||
19597 | :exmp. | |
19598 | ||
19599 | .*---------------------------------------------------------------------* | |
19600 | :h3.CER + DER encoding of OCTETSTRING, length = 0 (primitive) | |
19601 | .*---------------------------------------------------------------------* | |
19602 | :xmp tab=0. | |
19603 | ||
19604 | <TC - CER + DER encoding of OCTETSTRING, length = 0 (primitive)> | |
19605 | ||
19606 | <STATIC:ASN> | |
19607 | ||
19608 | TempA | |
19609 | ||
19610 | DEFINITIONS ::= | |
19611 | BEGIN | |
19612 | BERPDU ::= OCTET STRING | |
19613 | END | |
19614 | ||
19615 | <STATIC> | |
19616 | ||
19617 | import from TempA all; | |
19618 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
19619 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
19620 | ||
19621 | const BERPDU b := ''O | |
19622 | ||
19623 | <TTCN_TC:EXEC> | |
19624 | ||
19625 | if ((enc_DER_PDU(b) == '0400'O)and(enc_CER_PDU(b) == '0400'O)) {setverdict(pass);} else {setverdict(fail);} | |
19626 | ||
19627 | <RESULT> | |
19628 | ||
19629 | Overall verdict: pass | |
19630 | ||
19631 | <END_TC> | |
19632 | ||
19633 | :exmp. | |
19634 | ||
19635 | .*---------------------------------------------------------------------* | |
19636 | :h3.CER + DER encoding of OCTETSTRING, length = 2 (primitive) | |
19637 | .*---------------------------------------------------------------------* | |
19638 | :xmp tab=0. | |
19639 | ||
19640 | <TC - CER + DER encoding of OCTETSTRING, length = 2 (primitive)> | |
19641 | ||
19642 | <STATIC:ASN> | |
19643 | ||
19644 | TempA | |
19645 | ||
19646 | DEFINITIONS ::= | |
19647 | BEGIN | |
19648 | BERPDU ::= OCTET STRING | |
19649 | END | |
19650 | ||
19651 | <STATIC> | |
19652 | ||
19653 | import from TempA all; | |
19654 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
19655 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
19656 | ||
19657 | const BERPDU b := 'FFFF'O | |
19658 | ||
19659 | <TTCN_TC:EXEC> | |
19660 | ||
19661 | if ((enc_DER_PDU(b) == '0402FFFF'O)and(enc_CER_PDU(b) == '0402FFFF'O)) {setverdict(pass);} else {setverdict(fail);} | |
19662 | ||
19663 | <RESULT> | |
19664 | ||
19665 | Overall verdict: pass | |
19666 | ||
19667 | <END_TC> | |
19668 | ||
19669 | :exmp. | |
19670 | ||
19671 | .*---------------------------------------------------------------------* | |
19672 | :h3.CER + DER encoding of OCTETSTRING, length = 1000 (primitive) | |
19673 | .*---------------------------------------------------------------------* | |
19674 | :xmp tab=0. | |
19675 | ||
19676 | <TC - CER + DER encoding of OCTETSTRING, length = 1000 (primitive)> | |
19677 | ||
19678 | <STATIC:ASN> | |
19679 | ||
19680 | TempA | |
19681 | ||
19682 | DEFINITIONS ::= | |
19683 | BEGIN | |
19684 | BERPDU ::= OCTET STRING | |
19685 | END | |
19686 | ||
19687 | <STATIC> | |
19688 | ||
19689 | import from TempA all; | |
19690 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
19691 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
19692 | ||
19693 | const BERPDU b := 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O | |
19694 | ||
19695 | <TTCN_TC:EXEC> | |
19696 | ||
19697 | if ((enc_DER_PDU(b) == '048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)and(enc_CER_PDU(b) == '048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)) {setverdict(pass);} else {setverdict(fail);} | |
19698 | ||
19699 | <RESULT> | |
19700 | ||
19701 | Overall verdict: pass | |
19702 | ||
19703 | <END_TC> | |
19704 | ||
19705 | :exmp. | |
19706 | ||
19707 | .*---------------------------------------------------------------------* | |
19708 | :h3.CER(constructed) + DER(primitive) encoding of OCTETSTRING, length = 1001 (ENC_02_014 and ENC_02_015) | |
19709 | .*---------------------------------------------------------------------* | |
19710 | :xmp tab=0. | |
19711 | ||
19712 | <TC - CER(constructed) + DER(primitive) encoding of OCTETSTRING, length = 1001 (ENC_02_014 and ENC_02_015)> | |
19713 | ||
19714 | <STATIC:ASN> | |
19715 | ||
19716 | TempA | |
19717 | ||
19718 | DEFINITIONS ::= | |
19719 | BEGIN | |
19720 | BERPDU ::= OCTET STRING | |
19721 | END | |
19722 | ||
19723 | <STATIC> | |
19724 | ||
19725 | import from TempA all; | |
19726 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
19727 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
19728 | ||
19729 | const BERPDU b := | |
19730 | 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O | |
19731 | ||
19732 | <TTCN_TC:EXEC> | |
19733 | ||
19734 | if ((enc_DER_PDU(b) == '048203E9FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O)and(enc_CER_PDU(b) | |
19735 | == '2480048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0401FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
19736 | ||
19737 | <RESULT> | |
19738 | ||
19739 | Overall verdict: pass | |
19740 | ||
19741 | <END_TC> | |
19742 | ||
19743 | :exmp. | |
19744 | ||
19745 | .*---------------------------------------------------------------------* | |
19746 | :h3.CER + DER encoding of OCTETSTRING, IMPLICIT TAG length = 2 (primitive) | |
19747 | .*---------------------------------------------------------------------* | |
19748 | :xmp tab=0. | |
19749 | ||
19750 | <TC - CER + DER encoding of OCTETSTRING, IMPLICIT TAG length = 2 (primitive)> | |
19751 | ||
19752 | <STATIC:ASN> | |
19753 | ||
19754 | TempA | |
19755 | ||
19756 | DEFINITIONS ::= | |
19757 | BEGIN | |
19758 | BERPDU ::= [0] IMPLICIT OCTET STRING | |
19759 | END | |
19760 | ||
19761 | <STATIC> | |
19762 | ||
19763 | import from TempA all; | |
19764 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
19765 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
19766 | ||
19767 | const BERPDU b := 'FFFF'O | |
19768 | ||
19769 | <TTCN_TC:EXEC> | |
19770 | ||
19771 | if ((enc_DER_PDU(b) == '8002FFFF'O)and(enc_CER_PDU(b) == '8002FFFF'O)) {setverdict(pass);} else {setverdict(fail);} | |
19772 | ||
19773 | <RESULT> | |
19774 | ||
19775 | Overall verdict: pass | |
19776 | ||
19777 | <END_TC> | |
19778 | ||
19779 | :exmp. | |
19780 | ||
19781 | .*---------------------------------------------------------------------* | |
19782 | :h3.CER + DER encoding of OCTETSTRING,EXPICIT TAG , length = 2 (constructed) | |
19783 | .*---------------------------------------------------------------------* | |
19784 | :xmp tab=0. | |
19785 | ||
19786 | <TC - CER + DER encoding of OCTETSTRING,EXPICIT TAG , length = 2 (constructed)> | |
19787 | ||
19788 | <STATIC:ASN> | |
19789 | ||
19790 | TempA | |
19791 | ||
19792 | DEFINITIONS ::= | |
19793 | BEGIN | |
19794 | BERPDU ::= [0] EXPLICIT OCTET STRING | |
19795 | END | |
19796 | ||
19797 | <STATIC> | |
19798 | ||
19799 | import from TempA all; | |
19800 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
19801 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
19802 | ||
19803 | const BERPDU b := 'FFFF'O | |
19804 | ||
19805 | <TTCN_TC:EXEC> | |
19806 | ||
19807 | if ((enc_DER_PDU(b) == 'A0040402FFFF'O)and(enc_CER_PDU(b) == 'A0800402FFFF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
19808 | ||
19809 | <RESULT> | |
19810 | ||
19811 | Overall verdict: pass | |
19812 | ||
19813 | <END_TC> | |
19814 | ||
19815 | :exmp. | |
19816 | ||
19817 | .*---------------------------------------------------------------------* | |
19818 | :h3. DECODING OCTETSTRING ,length = 0 ,CER +DER (primitive) | |
19819 | .*---------------------------------------------------------------------* | |
19820 | :xmp tab=0. | |
19821 | ||
19822 | <TC - DECODING OCTETSTRING ,length = 0 ,CER +DER (primitive)> | |
19823 | ||
19824 | <STATIC:ASN> | |
19825 | ||
19826 | TempA | |
19827 | ||
19828 | DEFINITIONS ::= | |
19829 | BEGIN | |
19830 | BERPDU ::= OCTET STRING | |
19831 | ||
19832 | myIntegerValue BERPDU ::=''H | |
19833 | ||
19834 | END | |
19835 | ||
19836 | <STATIC> | |
19837 | ||
19838 | import from TempA all; | |
19839 | ||
19840 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19841 | ||
19842 | ||
19843 | <TTCN_TC:EXEC> | |
19844 | ||
19845 | if (dec_BER_PDU('0400'O) == myIntegerValue) | |
19846 | ||
19847 | ||
19848 | {setverdict(pass);} else {setverdict(fail);} | |
19849 | ||
19850 | ||
19851 | <RESULT> | |
19852 | ||
19853 | Overall verdict: pass | |
19854 | ||
19855 | <END_TC> | |
19856 | ||
19857 | :exmp. | |
19858 | ||
19859 | .*---------------------------------------------------------------------* | |
19860 | :h3. DECODING OCTETSTRING ,length = 0 ,constructed | |
19861 | .*---------------------------------------------------------------------* | |
19862 | :xmp tab=0. | |
19863 | ||
19864 | <TC - DECODING OCTETSTRING ,length = 0 ,constructed> | |
19865 | ||
19866 | <STATIC:ASN> | |
19867 | ||
19868 | TempA | |
19869 | ||
19870 | DEFINITIONS ::= | |
19871 | BEGIN | |
19872 | BERPDU ::= OCTET STRING | |
19873 | ||
19874 | myIntegerValue BERPDU ::=''H | |
19875 | ||
19876 | END | |
19877 | ||
19878 | <STATIC> | |
19879 | ||
19880 | import from TempA all; | |
19881 | ||
19882 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19883 | ||
19884 | ||
19885 | <TTCN_TC:EXEC> | |
19886 | ||
19887 | if (dec_BER_PDU('24020400'O) == myIntegerValue) | |
19888 | ||
19889 | ||
19890 | {setverdict(pass);} else {setverdict(fail);} | |
19891 | ||
19892 | ||
19893 | <RESULT> | |
19894 | ||
19895 | Overall verdict: pass | |
19896 | ||
19897 | <END_TC> | |
19898 | ||
19899 | :exmp. | |
19900 | ||
19901 | .*---------------------------------------------------------------------* | |
19902 | :h3. DECODING OCTETSTRING ,2xlength = 0 ,constructed | |
19903 | .*---------------------------------------------------------------------* | |
19904 | :xmp tab=0. | |
19905 | ||
19906 | <TC - DECODING OCTETSTRING ,2xlength = 0 ,constructed> | |
19907 | ||
19908 | <STATIC:ASN> | |
19909 | ||
19910 | TempA | |
19911 | ||
19912 | DEFINITIONS ::= | |
19913 | BEGIN | |
19914 | BERPDU ::= OCTET STRING | |
19915 | ||
19916 | myIntegerValue BERPDU ::=''H | |
19917 | ||
19918 | END | |
19919 | ||
19920 | <STATIC> | |
19921 | ||
19922 | import from TempA all; | |
19923 | ||
19924 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19925 | ||
19926 | ||
19927 | <TTCN_TC:EXEC> | |
19928 | ||
19929 | if (dec_BER_PDU('240404000400'O) == myIntegerValue) | |
19930 | ||
19931 | ||
19932 | {setverdict(pass);} else {setverdict(fail);} | |
19933 | ||
19934 | ||
19935 | <RESULT> | |
19936 | ||
19937 | Overall verdict: pass | |
19938 | ||
19939 | <END_TC> | |
19940 | ||
19941 | :exmp. | |
19942 | ||
19943 | .*---------------------------------------------------------------------* | |
19944 | :h3. DECODING OCTETSTRING ,length = 0 ,constructed, indefinite | |
19945 | .*---------------------------------------------------------------------* | |
19946 | :xmp tab=0. | |
19947 | ||
19948 | <TC - DECODING OCTETSTRING ,length = 0 ,constructed, indefinite> | |
19949 | ||
19950 | <STATIC:ASN> | |
19951 | ||
19952 | TempA | |
19953 | ||
19954 | DEFINITIONS ::= | |
19955 | BEGIN | |
19956 | BERPDU ::= OCTET STRING | |
19957 | ||
19958 | myIntegerValue BERPDU ::=''H | |
19959 | ||
19960 | END | |
19961 | ||
19962 | <STATIC> | |
19963 | ||
19964 | import from TempA all; | |
19965 | ||
19966 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
19967 | ||
19968 | ||
19969 | <TTCN_TC:EXEC> | |
19970 | ||
19971 | if (dec_BER_PDU('248004000000'O) == myIntegerValue) | |
19972 | ||
19973 | ||
19974 | {setverdict(pass);} else {setverdict(fail);} | |
19975 | ||
19976 | ||
19977 | <RESULT> | |
19978 | ||
19979 | Overall verdict: pass | |
19980 | ||
19981 | <END_TC> | |
19982 | ||
19983 | :exmp. | |
19984 | ||
19985 | .*---------------------------------------------------------------------* | |
19986 | :h3. DECODING OCTETSTRING ,length = 2 ,CER + DER, (primitive) | |
19987 | .*---------------------------------------------------------------------* | |
19988 | :xmp tab=0. | |
19989 | ||
19990 | <TC - DECODING OCTETSTRING ,length = 2 ,CER + DER, (primitive)> | |
19991 | ||
19992 | <STATIC:ASN> | |
19993 | ||
19994 | TempA | |
19995 | ||
19996 | DEFINITIONS ::= | |
19997 | BEGIN | |
19998 | BERPDU ::= OCTET STRING | |
19999 | ||
20000 | myIntegerValue BERPDU ::='FFFF'H | |
20001 | ||
20002 | END | |
20003 | ||
20004 | <STATIC> | |
20005 | ||
20006 | import from TempA all; | |
20007 | ||
20008 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20009 | ||
20010 | ||
20011 | <TTCN_TC:EXEC> | |
20012 | ||
20013 | if (dec_BER_PDU('0402FFFF'O) == myIntegerValue) | |
20014 | ||
20015 | ||
20016 | {setverdict(pass);} else {setverdict(fail);} | |
20017 | ||
20018 | ||
20019 | <RESULT> | |
20020 | ||
20021 | Overall verdict: pass | |
20022 | ||
20023 | <END_TC> | |
20024 | ||
20025 | :exmp. | |
20026 | ||
20027 | .*---------------------------------------------------------------------* | |
20028 | :h3. DECODING OCTETSTRING ,length = 2 , (primitive, long form) | |
20029 | .*---------------------------------------------------------------------* | |
20030 | :xmp tab=0. | |
20031 | ||
20032 | <TC - DECODING OCTETSTRING ,length = 2 , (primitive, long form)> | |
20033 | ||
20034 | <STATIC:ASN> | |
20035 | ||
20036 | TempA | |
20037 | ||
20038 | DEFINITIONS ::= | |
20039 | BEGIN | |
20040 | BERPDU ::= OCTET STRING | |
20041 | ||
20042 | myIntegerValue BERPDU ::='FFFF'H | |
20043 | ||
20044 | END | |
20045 | ||
20046 | <STATIC> | |
20047 | ||
20048 | import from TempA all; | |
20049 | ||
20050 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20051 | ||
20052 | ||
20053 | <TTCN_TC:EXEC> | |
20054 | ||
20055 | if (dec_BER_PDU('048102FFFF'O) == myIntegerValue) | |
20056 | ||
20057 | ||
20058 | {setverdict(pass);} else {setverdict(fail);} | |
20059 | ||
20060 | ||
20061 | <RESULT> | |
20062 | ||
20063 | Overall verdict: pass | |
20064 | ||
20065 | <END_TC> | |
20066 | ||
20067 | :exmp. | |
20068 | ||
20069 | .*---------------------------------------------------------------------* | |
20070 | :h3. DECODING OCTETSTRING ,length = 2 ,constructed, short form - short form | |
20071 | .*---------------------------------------------------------------------* | |
20072 | :xmp tab=0. | |
20073 | ||
20074 | <TC - DECODING OCTETSTRING ,length = 2 ,constructed, short form - short form> | |
20075 | ||
20076 | <STATIC:ASN> | |
20077 | ||
20078 | TempA | |
20079 | ||
20080 | DEFINITIONS ::= | |
20081 | BEGIN | |
20082 | BERPDU ::= OCTET STRING | |
20083 | ||
20084 | myIntegerValue BERPDU ::='FFFF'H | |
20085 | ||
20086 | END | |
20087 | ||
20088 | <STATIC> | |
20089 | ||
20090 | import from TempA all; | |
20091 | ||
20092 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20093 | ||
20094 | ||
20095 | <TTCN_TC:EXEC> | |
20096 | ||
20097 | if (dec_BER_PDU('24040402FFFF'O) == myIntegerValue) | |
20098 | ||
20099 | ||
20100 | {setverdict(pass);} else {setverdict(fail);} | |
20101 | ||
20102 | ||
20103 | <RESULT> | |
20104 | ||
20105 | Overall verdict: pass | |
20106 | ||
20107 | <END_TC> | |
20108 | ||
20109 | :exmp. | |
20110 | ||
20111 | .*---------------------------------------------------------------------* | |
20112 | :h3. DECODING OCTETSTRING ,length = 2 ,constructed, short form - long form | |
20113 | .*---------------------------------------------------------------------* | |
20114 | :xmp tab=0. | |
20115 | ||
20116 | <TC - DECODING OCTETSTRING ,length = 2 ,constructed, short form - long form> | |
20117 | ||
20118 | <STATIC:ASN> | |
20119 | ||
20120 | TempA | |
20121 | ||
20122 | DEFINITIONS ::= | |
20123 | BEGIN | |
20124 | BERPDU ::= OCTET STRING | |
20125 | ||
20126 | myIntegerValue BERPDU ::='FFFF'H | |
20127 | ||
20128 | END | |
20129 | ||
20130 | <STATIC> | |
20131 | ||
20132 | import from TempA all; | |
20133 | ||
20134 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20135 | ||
20136 | ||
20137 | <TTCN_TC:EXEC> | |
20138 | ||
20139 | if (dec_BER_PDU('2405048102FFFF'O) == myIntegerValue) | |
20140 | ||
20141 | ||
20142 | {setverdict(pass);} else {setverdict(fail);} | |
20143 | ||
20144 | ||
20145 | <RESULT> | |
20146 | ||
20147 | Overall verdict: pass | |
20148 | ||
20149 | <END_TC> | |
20150 | ||
20151 | :exmp. | |
20152 | ||
20153 | .*---------------------------------------------------------------------* | |
20154 | :h3. DECODING OCTETSTRING ,length = 2 ,constructed, long form - long form | |
20155 | .*---------------------------------------------------------------------* | |
20156 | :xmp tab=0. | |
20157 | ||
20158 | <TC - DECODING OCTETSTRING ,length = 2 ,constructed, long form - long form> | |
20159 | ||
20160 | <STATIC:ASN> | |
20161 | ||
20162 | TempA | |
20163 | ||
20164 | DEFINITIONS ::= | |
20165 | BEGIN | |
20166 | BERPDU ::= OCTET STRING | |
20167 | ||
20168 | myIntegerValue BERPDU ::='FFFF'H | |
20169 | ||
20170 | END | |
20171 | ||
20172 | <STATIC> | |
20173 | ||
20174 | import from TempA all; | |
20175 | ||
20176 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20177 | ||
20178 | ||
20179 | <TTCN_TC:EXEC> | |
20180 | ||
20181 | if (dec_BER_PDU('248105048102FFFF'O) == myIntegerValue) | |
20182 | ||
20183 | ||
20184 | {setverdict(pass);} else {setverdict(fail);} | |
20185 | ||
20186 | ||
20187 | <RESULT> | |
20188 | ||
20189 | Overall verdict: pass | |
20190 | ||
20191 | <END_TC> | |
20192 | ||
20193 | :exmp. | |
20194 | ||
20195 | .*---------------------------------------------------------------------* | |
20196 | :h3. DECODING OCTETSTRING ,length = 2 ,constructed, indefinite form | |
20197 | .*---------------------------------------------------------------------* | |
20198 | :xmp tab=0. | |
20199 | ||
20200 | <TC - DECODING OCTETSTRING ,length = 2 ,constructed, indefinite form> | |
20201 | ||
20202 | <STATIC:ASN> | |
20203 | ||
20204 | TempA | |
20205 | ||
20206 | DEFINITIONS ::= | |
20207 | BEGIN | |
20208 | BERPDU ::= OCTET STRING | |
20209 | ||
20210 | myIntegerValue BERPDU ::='FFFF'H | |
20211 | ||
20212 | END | |
20213 | ||
20214 | <STATIC> | |
20215 | ||
20216 | import from TempA all; | |
20217 | ||
20218 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20219 | ||
20220 | ||
20221 | <TTCN_TC:EXEC> | |
20222 | ||
20223 | if (dec_BER_PDU('24800402FFFF0000'O) == myIntegerValue) | |
20224 | ||
20225 | ||
20226 | {setverdict(pass);} else {setverdict(fail);} | |
20227 | ||
20228 | ||
20229 | <RESULT> | |
20230 | ||
20231 | Overall verdict: pass | |
20232 | ||
20233 | <END_TC> | |
20234 | ||
20235 | :exmp. | |
20236 | ||
20237 | .*---------------------------------------------------------------------* | |
20238 | :h3. DECODING OCTETSTRING ,2xlength = 2 ,constructed, short form - short form | |
20239 | .*---------------------------------------------------------------------* | |
20240 | :xmp tab=0. | |
20241 | ||
20242 | <TC - DECODING OCTETSTRING ,2xlength = 2 ,constructed, short form - short form> | |
20243 | ||
20244 | <STATIC:ASN> | |
20245 | ||
20246 | TempA | |
20247 | ||
20248 | DEFINITIONS ::= | |
20249 | BEGIN | |
20250 | BERPDU ::= OCTET STRING | |
20251 | ||
20252 | myIntegerValue BERPDU ::='FFFFFFFF'H | |
20253 | ||
20254 | END | |
20255 | ||
20256 | <STATIC> | |
20257 | ||
20258 | import from TempA all; | |
20259 | ||
20260 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20261 | ||
20262 | ||
20263 | <TTCN_TC:EXEC> | |
20264 | ||
20265 | if (dec_BER_PDU('24080402FFFF0402FFFF'O) == myIntegerValue) | |
20266 | ||
20267 | ||
20268 | {setverdict(pass);} else {setverdict(fail);} | |
20269 | ||
20270 | ||
20271 | <RESULT> | |
20272 | ||
20273 | Overall verdict: pass | |
20274 | ||
20275 | <END_TC> | |
20276 | ||
20277 | :exmp. | |
20278 | ||
20279 | .*---------------------------------------------------------------------* | |
20280 | :h3. DECODING OCTETSTRING ,length = 2 ,constructed form inside constructed form | |
20281 | .*---------------------------------------------------------------------* | |
20282 | :xmp tab=0. | |
20283 | ||
20284 | <TC - DECODING OCTETSTRING ,length = 2 ,constructed form inside constructed form> | |
20285 | ||
20286 | <STATIC:ASN> | |
20287 | ||
20288 | TempA | |
20289 | ||
20290 | DEFINITIONS ::= | |
20291 | BEGIN | |
20292 | BERPDU ::= OCTET STRING | |
20293 | ||
20294 | myIntegerValue BERPDU ::='FFFF'H | |
20295 | ||
20296 | END | |
20297 | ||
20298 | <STATIC> | |
20299 | ||
20300 | import from TempA all; | |
20301 | ||
20302 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20303 | ||
20304 | ||
20305 | <TTCN_TC:EXEC> | |
20306 | ||
20307 | if (dec_BER_PDU('240624040402FFFF'O) == myIntegerValue) | |
20308 | ||
20309 | ||
20310 | {setverdict(pass);} else {setverdict(fail);} | |
20311 | ||
20312 | ||
20313 | <RESULT> | |
20314 | ||
20315 | Overall verdict: pass | |
20316 | ||
20317 | <END_TC> | |
20318 | ||
20319 | :exmp. | |
20320 | ||
20321 | .*---------------------------------------------------------------------* | |
20322 | :h3. DECODING OCTETSTRING ,length = 1000 ,CER + DER, (primitive) | |
20323 | .*---------------------------------------------------------------------* | |
20324 | :xmp tab=0. | |
20325 | ||
20326 | <TC - DECODING OCTETSTRING ,length = 1000 ,CER + DER, (primitive)> | |
20327 | ||
20328 | <STATIC:ASN> | |
20329 | ||
20330 | TempA | |
20331 | ||
20332 | DEFINITIONS ::= | |
20333 | BEGIN | |
20334 | BERPDU ::= OCTET STRING | |
20335 | ||
20336 | myIntegerValue BERPDU | |
20337 | ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
20338 | ||
20339 | END | |
20340 | ||
20341 | <STATIC> | |
20342 | ||
20343 | import from TempA all; | |
20344 | ||
20345 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20346 | ||
20347 | ||
20348 | <TTCN_TC:EXEC> | |
20349 | ||
20350 | if (dec_BER_PDU('048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue) | |
20351 | ||
20352 | ||
20353 | {setverdict(pass);} else {setverdict(fail);} | |
20354 | ||
20355 | ||
20356 | <RESULT> | |
20357 | ||
20358 | Overall verdict: pass | |
20359 | ||
20360 | <END_TC> | |
20361 | ||
20362 | :exmp. | |
20363 | ||
20364 | .*---------------------------------------------------------------------* | |
20365 | :h3. DECODING OCTETSTRING ,length = 1000 , (primitive, longer form) | |
20366 | .*---------------------------------------------------------------------* | |
20367 | :xmp tab=0. | |
20368 | ||
20369 | <TC - DECODING OCTETSTRING ,length = 1000 , (primitive, longer form)> | |
20370 | ||
20371 | <STATIC:ASN> | |
20372 | ||
20373 | TempA | |
20374 | ||
20375 | DEFINITIONS ::= | |
20376 | BEGIN | |
20377 | BERPDU ::= OCTET STRING | |
20378 | ||
20379 | myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
20380 | ||
20381 | END | |
20382 | ||
20383 | <STATIC> | |
20384 | ||
20385 | import from TempA all; | |
20386 | ||
20387 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20388 | ||
20389 | ||
20390 | <TTCN_TC:EXEC> | |
20391 | ||
20392 | if (dec_BER_PDU('04830003E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue) | |
20393 | ||
20394 | ||
20395 | {setverdict(pass);} else {setverdict(fail);} | |
20396 | ||
20397 | ||
20398 | <RESULT> | |
20399 | ||
20400 | Overall verdict: pass | |
20401 | ||
20402 | <END_TC> | |
20403 | ||
20404 | :exmp. | |
20405 | ||
20406 | .*---------------------------------------------------------------------* | |
20407 | :h3. DECODING OCTETSTRING ,length = 1000 ,constructed, long form -long form | |
20408 | .*---------------------------------------------------------------------* | |
20409 | :xmp tab=0. | |
20410 | ||
20411 | <TC - DECODING OCTETSTRING ,length = 1000 ,constructed, long form -long form> | |
20412 | ||
20413 | <STATIC:ASN> | |
20414 | ||
20415 | TempA | |
20416 | ||
20417 | DEFINITIONS ::= | |
20418 | BEGIN | |
20419 | BERPDU ::= OCTET STRING | |
20420 | ||
20421 | myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
20422 | ||
20423 | END | |
20424 | ||
20425 | <STATIC> | |
20426 | ||
20427 | import from TempA all; | |
20428 | ||
20429 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20430 | ||
20431 | ||
20432 | <TTCN_TC:EXEC> | |
20433 | ||
20434 | if (dec_BER_PDU('248203EC048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue) | |
20435 | ||
20436 | ||
20437 | {setverdict(pass);} else {setverdict(fail);} | |
20438 | ||
20439 | ||
20440 | <RESULT> | |
20441 | ||
20442 | Overall verdict: pass | |
20443 | ||
20444 | <END_TC> | |
20445 | ||
20446 | :exmp. | |
20447 | ||
20448 | .*---------------------------------------------------------------------* | |
20449 | :h3. DECODING OCTETSTRING ,length = 1000 ,constructed, indefinite form | |
20450 | .*---------------------------------------------------------------------* | |
20451 | :xmp tab=0. | |
20452 | ||
20453 | <TC - DECODING OCTETSTRING ,length = 1000 ,constructed, indefinite form> | |
20454 | ||
20455 | <STATIC:ASN> | |
20456 | ||
20457 | TempA | |
20458 | ||
20459 | DEFINITIONS ::= | |
20460 | BEGIN | |
20461 | BERPDU ::= OCTET STRING | |
20462 | ||
20463 | myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
20464 | ||
20465 | END | |
20466 | ||
20467 | <STATIC> | |
20468 | ||
20469 | import from TempA all; | |
20470 | ||
20471 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20472 | ||
20473 | ||
20474 | <TTCN_TC:EXEC> | |
20475 | ||
20476 | if (dec_BER_PDU('2480048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000'O) == myIntegerValue) | |
20477 | ||
20478 | ||
20479 | {setverdict(pass);} else {setverdict(fail);} | |
20480 | ||
20481 | ||
20482 | <RESULT> | |
20483 | ||
20484 | Overall verdict: pass | |
20485 | ||
20486 | <END_TC> | |
20487 | ||
20488 | :exmp. | |
20489 | ||
20490 | .*---------------------------------------------------------------------* | |
20491 | :h3. DECODING OCTETSTRING ,2xlength = 1000 ,constructed, short form - short form | |
20492 | .*---------------------------------------------------------------------* | |
20493 | :xmp tab=0. | |
20494 | ||
20495 | <TC - DECODING OCTETSTRING ,2xlength = 1000 ,constructed, short form - short form> | |
20496 | ||
20497 | <STATIC:ASN> | |
20498 | ||
20499 | TempA | |
20500 | ||
20501 | DEFINITIONS ::= | |
20502 | BEGIN | |
20503 | BERPDU ::= OCTET STRING | |
20504 | ||
20505 | myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
20506 | ||
20507 | END | |
20508 | ||
20509 | <STATIC> | |
20510 | ||
20511 | import from TempA all; | |
20512 | ||
20513 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20514 | ||
20515 | ||
20516 | <TTCN_TC:EXEC> | |
20517 | ||
20518 | if (dec_BER_PDU('248207D8048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue) | |
20519 | ||
20520 | ||
20521 | {setverdict(pass);} else {setverdict(fail);} | |
20522 | ||
20523 | ||
20524 | <RESULT> | |
20525 | ||
20526 | Overall verdict: pass | |
20527 | ||
20528 | <END_TC> | |
20529 | ||
20530 | :exmp. | |
20531 | ||
20532 | .*---------------------------------------------------------------------* | |
20533 | :h3. DECODING OCTETSTRING ,length = 1001 ,CER (constructed, indefinite form. segmented) | |
20534 | .*---------------------------------------------------------------------* | |
20535 | :xmp tab=0. | |
20536 | ||
20537 | <TC - DECODING OCTETSTRING ,length = 1001 ,CER (constructed, indefinite form. segmented)> | |
20538 | ||
20539 | <STATIC:ASN> | |
20540 | ||
20541 | TempA | |
20542 | ||
20543 | DEFINITIONS ::= | |
20544 | BEGIN | |
20545 | BERPDU ::= OCTET STRING | |
20546 | myIntegerValue BERPDU ::= 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
20547 | ||
20548 | ||
20549 | END | |
20550 | ||
20551 | <STATIC> | |
20552 | ||
20553 | import from TempA all; | |
20554 | ||
20555 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20556 | ||
20557 | ||
20558 | <TTCN_TC:EXEC> | |
20559 | ||
20560 | if (dec_BER_PDU('2480048203E8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0401FF0000'O) == myIntegerValue) | |
20561 | ||
20562 | ||
20563 | {setverdict(pass);} else {setverdict(fail);} | |
20564 | ||
20565 | ||
20566 | <RESULT> | |
20567 | ||
20568 | Overall verdict: pass | |
20569 | ||
20570 | <END_TC> | |
20571 | ||
20572 | :exmp. | |
20573 | ||
20574 | .*---------------------------------------------------------------------* | |
20575 | :h3. DECODING OCTETSTRING ,length = 1001 ,DER (primitive) | |
20576 | .*---------------------------------------------------------------------* | |
20577 | :xmp tab=0. | |
20578 | ||
20579 | <TC - DECODING OCTETSTRING ,length = 1001 ,DER (primitive)> | |
20580 | ||
20581 | <STATIC:ASN> | |
20582 | ||
20583 | TempA | |
20584 | ||
20585 | DEFINITIONS ::= | |
20586 | BEGIN | |
20587 | BERPDU ::= OCTET STRING | |
20588 | myIntegerValue BERPDU ::='FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
20589 | ||
20590 | ||
20591 | ||
20592 | END | |
20593 | ||
20594 | <STATIC> | |
20595 | ||
20596 | import from TempA all; | |
20597 | ||
20598 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20599 | ||
20600 | ||
20601 | <TTCN_TC:EXEC> | |
20602 | ||
20603 | if (dec_BER_PDU('048203E9FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue) | |
20604 | ||
20605 | ||
20606 | {setverdict(pass);} else {setverdict(fail);} | |
20607 | ||
20608 | ||
20609 | <RESULT> | |
20610 | ||
20611 | Overall verdict: pass | |
20612 | ||
20613 | <END_TC> | |
20614 | ||
20615 | :exmp. | |
20616 | ||
20617 | .*---------------------------------------------------------------------* | |
20618 | :h3. DECODING OCTETSTRING ,length = 1001 ,constructed, definite form | |
20619 | .*---------------------------------------------------------------------* | |
20620 | :xmp tab=0. | |
20621 | ||
20622 | <TC - DECODING OCTETSTRING ,length = 1001 ,constructed, definite form> | |
20623 | ||
20624 | <STATIC:ASN> | |
20625 | ||
20626 | TempA | |
20627 | ||
20628 | DEFINITIONS ::= | |
20629 | BEGIN | |
20630 | BERPDU ::= OCTET STRING | |
20631 | myIntegerValue BERPDU ::= 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'H | |
20632 | ||
20633 | ||
20634 | END | |
20635 | ||
20636 | <STATIC> | |
20637 | ||
20638 | import from TempA all; | |
20639 | ||
20640 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20641 | ||
20642 | ||
20643 | <TTCN_TC:EXEC> | |
20644 | ||
20645 | if (dec_BER_PDU('248203ED048203E9FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O) == myIntegerValue) | |
20646 | ||
20647 | ||
20648 | {setverdict(pass);} else {setverdict(fail);} | |
20649 | ||
20650 | ||
20651 | <RESULT> | |
20652 | ||
20653 | Overall verdict: pass | |
20654 | ||
20655 | <END_TC> | |
20656 | ||
20657 | :exmp. | |
20658 | ||
20659 | .*---------------------------------------------------------------------* | |
20660 | :h3. DECODING OCTETSTRING ,length = 2 ,CER + DER,IMPLICIT TAG (primitive) | |
20661 | .*---------------------------------------------------------------------* | |
20662 | :xmp tab=0. | |
20663 | ||
20664 | <TC - DECODING OCTETSTRING ,length = 2 ,CER + DER,IMPLICIT TAG (primitive)> | |
20665 | ||
20666 | <STATIC:ASN> | |
20667 | ||
20668 | TempA | |
20669 | ||
20670 | DEFINITIONS ::= | |
20671 | BEGIN | |
20672 | BERPDU ::= [0] IMPLICIT OCTET STRING | |
20673 | ||
20674 | myIntegerValue BERPDU ::='FFFF'H | |
20675 | ||
20676 | END | |
20677 | ||
20678 | <STATIC> | |
20679 | ||
20680 | import from TempA all; | |
20681 | ||
20682 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20683 | ||
20684 | ||
20685 | <TTCN_TC:EXEC> | |
20686 | ||
20687 | if (dec_BER_PDU('8002FFFF'O) == myIntegerValue) | |
20688 | ||
20689 | ||
20690 | {setverdict(pass);} else {setverdict(fail);} | |
20691 | ||
20692 | ||
20693 | <RESULT> | |
20694 | ||
20695 | Overall verdict: pass | |
20696 | ||
20697 | <END_TC> | |
20698 | ||
20699 | :exmp. | |
20700 | ||
20701 | .*---------------------------------------------------------------------* | |
20702 | :h3. DECODING OCTETSTRING ,length = 2 ,CER ,EXPLICIT TAG (constructed) | |
20703 | .*---------------------------------------------------------------------* | |
20704 | :xmp tab=0. | |
20705 | ||
20706 | <TC - DECODING OCTETSTRING ,length = 2 ,CER ,EXPLICIT TAG (constructed)> | |
20707 | ||
20708 | <STATIC:ASN> | |
20709 | ||
20710 | TempA | |
20711 | ||
20712 | DEFINITIONS ::= | |
20713 | BEGIN | |
20714 | BERPDU ::= [0] EXPLICIT OCTET STRING | |
20715 | ||
20716 | myIntegerValue BERPDU ::='FFFF'H | |
20717 | ||
20718 | END | |
20719 | ||
20720 | <STATIC> | |
20721 | ||
20722 | import from TempA all; | |
20723 | ||
20724 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20725 | ||
20726 | ||
20727 | <TTCN_TC:EXEC> | |
20728 | ||
20729 | if (dec_BER_PDU('A0800402FFFF0000'O) == myIntegerValue) | |
20730 | ||
20731 | ||
20732 | {setverdict(pass);} else {setverdict(fail);} | |
20733 | ||
20734 | ||
20735 | <RESULT> | |
20736 | ||
20737 | Overall verdict: pass | |
20738 | ||
20739 | <END_TC> | |
20740 | ||
20741 | :exmp. | |
20742 | ||
20743 | .*---------------------------------------------------------------------* | |
20744 | :h3. DECODING OCTETSTRING ,length = 2 ,DER,EXPLICIT TAG (constructed) | |
20745 | .*---------------------------------------------------------------------* | |
20746 | :xmp tab=0. | |
20747 | ||
20748 | <TC - DECODING OCTETSTRING ,length = 2 ,DER,EXPLICIT TAG (constructed)> | |
20749 | ||
20750 | <STATIC:ASN> | |
20751 | ||
20752 | TempA | |
20753 | ||
20754 | DEFINITIONS ::= | |
20755 | BEGIN | |
20756 | BERPDU ::= OCTET STRING | |
20757 | ||
20758 | myIntegerValue BERPDU ::='FFFF'H | |
20759 | ||
20760 | END | |
20761 | ||
20762 | <STATIC> | |
20763 | ||
20764 | import from TempA all; | |
20765 | ||
20766 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
20767 | ||
20768 | ||
20769 | <TTCN_TC:EXEC> | |
20770 | ||
20771 | if (dec_BER_PDU('A0040402FFFF'O) == myIntegerValue) | |
20772 | ||
20773 | ||
20774 | {setverdict(pass);} else {setverdict(fail);} | |
20775 | ||
20776 | ||
20777 | <RESULT> | |
20778 | ||
20779 | Overall verdict: pass | |
20780 | ||
20781 | <END_TC> | |
20782 | ||
20783 | :exmp. | |
20784 | ||
20785 | .*---------------------------------------------------------------------* | |
20786 | :h3. DER + CER encoding of NULL | |
20787 | .*---------------------------------------------------------------------* | |
20788 | :xmp tab=0. | |
20789 | ||
20790 | <TC - DER + CER encoding of NULL > | |
20791 | START OF NULL SECTION | |
20792 | ||
20793 | <STATIC:ASN> | |
20794 | ||
20795 | TempA | |
20796 | ||
20797 | DEFINITIONS ::= | |
20798 | BEGIN | |
20799 | BERPDU ::= NULL | |
20800 | END | |
20801 | ||
20802 | <STATIC> | |
20803 | ||
20804 | import from TempA all; | |
20805 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
20806 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
20807 | ||
20808 | const BERPDU b := NULL | |
20809 | ||
20810 | <TTCN_TC:EXEC> | |
20811 | ||
20812 | if ((enc_DER_PDU(b) == '0500'O)and(enc_CER_PDU(b) == '0500'O)) {setverdict(pass);} else {setverdict(fail);} | |
20813 | ||
20814 | <RESULT> | |
20815 | ||
20816 | Overall verdict: pass | |
20817 | ||
20818 | <END_TC> | |
20819 | ||
20820 | :exmp. | |
20821 | ||
20822 | .*---------------------------------------------------------------------* | |
20823 | :h3. DER + CER encoding of NULL with Context Specific TAG, EXPLICIT | |
20824 | .*---------------------------------------------------------------------* | |
20825 | :xmp tab=0. | |
20826 | ||
20827 | <TC - DER + CER encoding of NULL with Context Specific TAG, EXPLICIT> | |
20828 | ||
20829 | <STATIC:ASN> | |
20830 | ||
20831 | TempA | |
20832 | ||
20833 | DEFINITIONS ::= | |
20834 | BEGIN | |
20835 | BERPDU ::= [0] EXPLICIT NULL | |
20836 | END | |
20837 | ||
20838 | <STATIC> | |
20839 | ||
20840 | import from TempA all; | |
20841 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
20842 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
20843 | ||
20844 | const BERPDU b := NULL | |
20845 | ||
20846 | <TTCN_TC:EXEC> | |
20847 | ||
20848 | if ((enc_DER_PDU(b) == 'A0020500'O)and(enc_CER_PDU(b) == 'A08005000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
20849 | ||
20850 | <RESULT> | |
20851 | ||
20852 | Overall verdict: pass | |
20853 | ||
20854 | <END_TC> | |
20855 | ||
20856 | :exmp. | |
20857 | ||
20858 | .*---------------------------------------------------------------------* | |
20859 | :h3. DER + CER encoding of NULL with PRIVATE TAG, EXPLICIT | |
20860 | .*---------------------------------------------------------------------* | |
20861 | :xmp tab=0. | |
20862 | ||
20863 | <TC - DER + CER encoding of NULL with PRIVATE TAG, EXPLICIT> | |
20864 | ||
20865 | <STATIC:ASN> | |
20866 | ||
20867 | TempA | |
20868 | ||
20869 | DEFINITIONS ::= | |
20870 | BEGIN | |
20871 | BERPDU ::= [PRIVATE 1] EXPLICIT NULL | |
20872 | END | |
20873 | ||
20874 | <STATIC> | |
20875 | ||
20876 | import from TempA all; | |
20877 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
20878 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
20879 | ||
20880 | const BERPDU b := NULL | |
20881 | ||
20882 | <TTCN_TC:EXEC> | |
20883 | ||
20884 | if ((enc_DER_PDU(b) == 'E1020500'O)and(enc_CER_PDU(b) == 'E18005000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
20885 | ||
20886 | <RESULT> | |
20887 | ||
20888 | Overall verdict: pass | |
20889 | ||
20890 | <END_TC> | |
20891 | ||
20892 | :exmp. | |
20893 | ||
20894 | .*---------------------------------------------------------------------* | |
20895 | :h3. DER + CER encoding of NULL with APPLICATION TAG, EXPLICIT | |
20896 | .*---------------------------------------------------------------------* | |
20897 | :xmp tab=0. | |
20898 | ||
20899 | <TC - DER + CER encoding of NULL with APPLICATION TAG, EXPLICIT> | |
20900 | ||
20901 | <STATIC:ASN> | |
20902 | ||
20903 | TempA | |
20904 | ||
20905 | DEFINITIONS ::= | |
20906 | BEGIN | |
20907 | BERPDU ::= [APPLICATION 2] EXPLICIT NULL | |
20908 | END | |
20909 | ||
20910 | <STATIC> | |
20911 | ||
20912 | import from TempA all; | |
20913 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
20914 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
20915 | ||
20916 | const BERPDU b := NULL | |
20917 | ||
20918 | <TTCN_TC:EXEC> | |
20919 | ||
20920 | if ((enc_DER_PDU(b) == '62020500'O)and(enc_CER_PDU(b) == '628005000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
20921 | ||
20922 | <RESULT> | |
20923 | ||
20924 | Overall verdict: pass | |
20925 | ||
20926 | <END_TC> | |
20927 | ||
20928 | :exmp. | |
20929 | ||
20930 | .*---------------------------------------------------------------------* | |
20931 | :h3. DER + CER encoding of NULL with Context Specific TAG, IMPLICIT | |
20932 | .*---------------------------------------------------------------------* | |
20933 | :xmp tab=0. | |
20934 | ||
20935 | <TC - DER + CER encoding of NULL with Context Specific TAG, IMPLICIT> | |
20936 | ||
20937 | <STATIC:ASN> | |
20938 | ||
20939 | TempA | |
20940 | ||
20941 | DEFINITIONS ::= | |
20942 | BEGIN | |
20943 | BERPDU ::= [0] IMPLICIT NULL | |
20944 | END | |
20945 | ||
20946 | <STATIC> | |
20947 | ||
20948 | import from TempA all; | |
20949 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
20950 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
20951 | ||
20952 | const BERPDU b := NULL | |
20953 | ||
20954 | <TTCN_TC:EXEC> | |
20955 | ||
20956 | if ((enc_DER_PDU(b) == '8000'O)and(enc_CER_PDU(b) == '8000'O)) {setverdict(pass);} else {setverdict(fail);} | |
20957 | ||
20958 | <RESULT> | |
20959 | ||
20960 | Overall verdict: pass | |
20961 | ||
20962 | <END_TC> | |
20963 | ||
20964 | :exmp. | |
20965 | ||
20966 | .*---------------------------------------------------------------------* | |
20967 | :h3. DER + CER encoding of NULL with PRIVATE TAG, IMPLICIT | |
20968 | .*---------------------------------------------------------------------* | |
20969 | :xmp tab=0. | |
20970 | ||
20971 | <TC - DER + CER encoding of NULL with PRIVATE TAG, IMPLICIT> | |
20972 | ||
20973 | <STATIC:ASN> | |
20974 | ||
20975 | TempA | |
20976 | ||
20977 | DEFINITIONS ::= | |
20978 | BEGIN | |
20979 | BERPDU ::= [PRIVATE 1] IMPLICIT NULL | |
20980 | END | |
20981 | ||
20982 | <STATIC> | |
20983 | ||
20984 | import from TempA all; | |
20985 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
20986 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
20987 | ||
20988 | const BERPDU b := NULL | |
20989 | ||
20990 | <TTCN_TC:EXEC> | |
20991 | ||
20992 | if ((enc_DER_PDU(b) == 'C100'O)and(enc_CER_PDU(b) == 'C100'O)) {setverdict(pass);} else {setverdict(fail);} | |
20993 | ||
20994 | <RESULT> | |
20995 | ||
20996 | Overall verdict: pass | |
20997 | ||
20998 | <END_TC> | |
20999 | ||
21000 | :exmp. | |
21001 | ||
21002 | .*---------------------------------------------------------------------* | |
21003 | :h3. DER + CER encoding of NULL with APPLICATION TAG, IMPLICIT | |
21004 | .*---------------------------------------------------------------------* | |
21005 | :xmp tab=0. | |
21006 | ||
21007 | <TC - DER + CER encoding of NULL with APPLICATION TAG, IMPLICIT> | |
21008 | ||
21009 | <STATIC:ASN> | |
21010 | ||
21011 | TempA | |
21012 | ||
21013 | DEFINITIONS ::= | |
21014 | BEGIN | |
21015 | BERPDU ::= [APPLICATION 2] IMPLICIT NULL | |
21016 | END | |
21017 | ||
21018 | <STATIC> | |
21019 | ||
21020 | import from TempA all; | |
21021 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
21022 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
21023 | ||
21024 | const BERPDU b := NULL | |
21025 | ||
21026 | <TTCN_TC:EXEC> | |
21027 | ||
21028 | if ((enc_DER_PDU(b) == '4200'O)and(enc_CER_PDU(b) == '4200'O)) {setverdict(pass);} else {setverdict(fail);} | |
21029 | ||
21030 | <RESULT> | |
21031 | ||
21032 | Overall verdict: pass | |
21033 | ||
21034 | <END_TC> | |
21035 | ||
21036 | :exmp. | |
21037 | ||
21038 | .*---------------------------------------------------------------------* | |
21039 | :h3. DECODING NULL, CER+DER | |
21040 | .*---------------------------------------------------------------------* | |
21041 | :xmp tab=0. | |
21042 | ||
21043 | <TC - DECODING NULL, CER+DER> | |
21044 | ||
21045 | <STATIC:ASN> | |
21046 | ||
21047 | TempA | |
21048 | ||
21049 | DEFINITIONS ::= | |
21050 | BEGIN | |
21051 | BERPDU ::= NULL | |
21052 | ||
21053 | myNullValue BERPDU ::= NULL | |
21054 | ||
21055 | END | |
21056 | ||
21057 | <STATIC> | |
21058 | ||
21059 | import from TempA all; | |
21060 | ||
21061 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21062 | ||
21063 | ||
21064 | <TTCN_TC:EXEC> | |
21065 | ||
21066 | if (dec_BER_PDU('0500'O) == myNullValue) | |
21067 | ||
21068 | ||
21069 | {setverdict(pass);} else {setverdict(fail);} | |
21070 | ||
21071 | ||
21072 | <RESULT> | |
21073 | ||
21074 | Overall verdict: pass | |
21075 | ||
21076 | <END_TC> | |
21077 | ||
21078 | :exmp. | |
21079 | ||
21080 | .*---------------------------------------------------------------------* | |
21081 | :h3. DECODING NULL, (LENGTH OF LENGTH = 1) | |
21082 | .*---------------------------------------------------------------------* | |
21083 | :xmp tab=0. | |
21084 | ||
21085 | <TC - DECODING NULL, (LENGTH OF LENGTH = 1)> | |
21086 | ||
21087 | <STATIC:ASN> | |
21088 | ||
21089 | TempA | |
21090 | ||
21091 | DEFINITIONS ::= | |
21092 | BEGIN | |
21093 | BERPDU ::= NULL | |
21094 | ||
21095 | myNullValue BERPDU ::= NULL | |
21096 | ||
21097 | END | |
21098 | ||
21099 | <STATIC> | |
21100 | ||
21101 | import from TempA all; | |
21102 | ||
21103 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21104 | ||
21105 | ||
21106 | <TTCN_TC:EXEC> | |
21107 | ||
21108 | if (dec_BER_PDU('058100'O) == myNullValue) | |
21109 | ||
21110 | ||
21111 | {setverdict(pass);} else {setverdict(fail);} | |
21112 | ||
21113 | ||
21114 | <RESULT> | |
21115 | ||
21116 | Overall verdict: pass | |
21117 | ||
21118 | <END_TC> | |
21119 | ||
21120 | :exmp. | |
21121 | ||
21122 | .*---------------------------------------------------------------------* | |
21123 | :h3. DECODING NULL, (LENGTH OF LENGTH = 2) | |
21124 | .*---------------------------------------------------------------------* | |
21125 | :xmp tab=0. | |
21126 | ||
21127 | <TC - DECODING NULL, (LENGTH OF LENGTH = 2)> | |
21128 | ||
21129 | <STATIC:ASN> | |
21130 | ||
21131 | TempA | |
21132 | ||
21133 | DEFINITIONS ::= | |
21134 | BEGIN | |
21135 | BERPDU ::= NULL | |
21136 | ||
21137 | myNullValue BERPDU ::= NULL | |
21138 | ||
21139 | END | |
21140 | ||
21141 | <STATIC> | |
21142 | ||
21143 | import from TempA all; | |
21144 | ||
21145 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21146 | ||
21147 | ||
21148 | <TTCN_TC:EXEC> | |
21149 | ||
21150 | if (dec_BER_PDU('05820000'O) == myNullValue) | |
21151 | ||
21152 | ||
21153 | {setverdict(pass);} else {setverdict(fail);} | |
21154 | ||
21155 | ||
21156 | <RESULT> | |
21157 | ||
21158 | Overall verdict: pass | |
21159 | ||
21160 | <END_TC> | |
21161 | ||
21162 | :exmp. | |
21163 | ||
21164 | .*---------------------------------------------------------------------* | |
21165 | :h3. DECODING [0] EXPLICIT NULL , DER | |
21166 | .*---------------------------------------------------------------------* | |
21167 | :xmp tab=0. | |
21168 | ||
21169 | <TC - DECODING [0] EXPLICIT NULL , DER> | |
21170 | ||
21171 | <STATIC:ASN> | |
21172 | ||
21173 | TempA | |
21174 | ||
21175 | DEFINITIONS ::= | |
21176 | BEGIN | |
21177 | BERPDU ::= [0] EXPLICIT NULL | |
21178 | ||
21179 | myNullValue BERPDU ::= NULL | |
21180 | ||
21181 | END | |
21182 | ||
21183 | <STATIC> | |
21184 | ||
21185 | import from TempA all; | |
21186 | ||
21187 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21188 | ||
21189 | ||
21190 | <TTCN_TC:EXEC> | |
21191 | ||
21192 | if (dec_BER_PDU('A0020500'O) == myNullValue) | |
21193 | ||
21194 | ||
21195 | {setverdict(pass);} else {setverdict(fail);} | |
21196 | ||
21197 | ||
21198 | <RESULT> | |
21199 | ||
21200 | Overall verdict: pass | |
21201 | ||
21202 | <END_TC> | |
21203 | ||
21204 | :exmp. | |
21205 | ||
21206 | .*---------------------------------------------------------------------* | |
21207 | :h3. DECODING [0] EXPLICIT NULL, CER | |
21208 | .*---------------------------------------------------------------------* | |
21209 | :xmp tab=0. | |
21210 | ||
21211 | <TC - DECODING [0] EXPLICIT NULL, CER> | |
21212 | ||
21213 | <STATIC:ASN> | |
21214 | ||
21215 | TempA | |
21216 | ||
21217 | DEFINITIONS ::= | |
21218 | BEGIN | |
21219 | BERPDU ::= [0] EXPLICIT NULL | |
21220 | ||
21221 | myNullValue BERPDU ::= NULL | |
21222 | ||
21223 | END | |
21224 | ||
21225 | <STATIC> | |
21226 | ||
21227 | import from TempA all; | |
21228 | ||
21229 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21230 | ||
21231 | ||
21232 | <TTCN_TC:EXEC> | |
21233 | ||
21234 | if (dec_BER_PDU('A08005000000'O) == myNullValue) | |
21235 | ||
21236 | ||
21237 | {setverdict(pass);} else {setverdict(fail);} | |
21238 | ||
21239 | ||
21240 | <RESULT> | |
21241 | ||
21242 | Overall verdict: pass | |
21243 | ||
21244 | <END_TC> | |
21245 | ||
21246 | :exmp. | |
21247 | ||
21248 | .*---------------------------------------------------------------------* | |
21249 | :h3. DECODING [0] EXPLICIT NULL, Short form - short form | |
21250 | .*---------------------------------------------------------------------* | |
21251 | :xmp tab=0. | |
21252 | ||
21253 | <TC - DECODING [0] EXPLICIT NULL, Short form - short form> | |
21254 | ||
21255 | <STATIC:ASN> | |
21256 | ||
21257 | TempA | |
21258 | ||
21259 | DEFINITIONS ::= | |
21260 | BEGIN | |
21261 | BERPDU ::= [0] EXPLICIT NULL | |
21262 | ||
21263 | myNullValue BERPDU ::= NULL | |
21264 | ||
21265 | END | |
21266 | ||
21267 | <STATIC> | |
21268 | ||
21269 | import from TempA all; | |
21270 | ||
21271 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21272 | ||
21273 | ||
21274 | <TTCN_TC:EXEC> | |
21275 | ||
21276 | if (dec_BER_PDU('A0020500'O) == myNullValue) | |
21277 | ||
21278 | ||
21279 | {setverdict(pass);} else {setverdict(fail);} | |
21280 | ||
21281 | ||
21282 | <RESULT> | |
21283 | ||
21284 | Overall verdict: pass | |
21285 | ||
21286 | <END_TC> | |
21287 | ||
21288 | :exmp. | |
21289 | ||
21290 | .*---------------------------------------------------------------------* | |
21291 | :h3. DECODING [0] EXPLICIT NULL, Long form - short form | |
21292 | .*---------------------------------------------------------------------* | |
21293 | :xmp tab=0. | |
21294 | ||
21295 | <TC - DECODING [0] EXPLICIT NULL, Long form - short form> | |
21296 | ||
21297 | <STATIC:ASN> | |
21298 | ||
21299 | TempA | |
21300 | ||
21301 | DEFINITIONS ::= | |
21302 | BEGIN | |
21303 | BERPDU ::= [0] EXPLICIT NULL | |
21304 | ||
21305 | myNullValue BERPDU ::= NULL | |
21306 | ||
21307 | END | |
21308 | ||
21309 | <STATIC> | |
21310 | ||
21311 | import from TempA all; | |
21312 | ||
21313 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21314 | ||
21315 | ||
21316 | <TTCN_TC:EXEC> | |
21317 | ||
21318 | if (dec_BER_PDU('A081020500'O) == myNullValue) | |
21319 | ||
21320 | ||
21321 | {setverdict(pass);} else {setverdict(fail);} | |
21322 | ||
21323 | ||
21324 | <RESULT> | |
21325 | ||
21326 | Overall verdict: pass | |
21327 | ||
21328 | <END_TC> | |
21329 | ||
21330 | :exmp. | |
21331 | ||
21332 | .*---------------------------------------------------------------------* | |
21333 | :h3. DECODING [0] EXPLICIT NULL, Long form Long form | |
21334 | .*---------------------------------------------------------------------* | |
21335 | :xmp tab=0. | |
21336 | ||
21337 | <TC - DECODING [0] EXPLICIT NULL, Long form Long form> | |
21338 | ||
21339 | <STATIC:ASN> | |
21340 | ||
21341 | TempA | |
21342 | ||
21343 | DEFINITIONS ::= | |
21344 | BEGIN | |
21345 | BERPDU ::= [0] EXPLICIT NULL | |
21346 | ||
21347 | myNullValue BERPDU ::= NULL | |
21348 | ||
21349 | END | |
21350 | ||
21351 | <STATIC> | |
21352 | ||
21353 | import from TempA all; | |
21354 | ||
21355 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21356 | ||
21357 | ||
21358 | <TTCN_TC:EXEC> | |
21359 | ||
21360 | if (dec_BER_PDU('A08103058100'O) == myNullValue) | |
21361 | ||
21362 | ||
21363 | {setverdict(pass);} else {setverdict(fail);} | |
21364 | ||
21365 | ||
21366 | <RESULT> | |
21367 | ||
21368 | Overall verdict: pass | |
21369 | ||
21370 | <END_TC> | |
21371 | ||
21372 | :exmp. | |
21373 | ||
21374 | .*---------------------------------------------------------------------* | |
21375 | :h3. DECODING [PRIVATE 1] EXPLICIT NULL , DER | |
21376 | .*---------------------------------------------------------------------* | |
21377 | :xmp tab=0. | |
21378 | ||
21379 | <TC - DECODING [PRIVATE 1] EXPLICIT NULL , DER> | |
21380 | ||
21381 | <STATIC:ASN> | |
21382 | ||
21383 | TempA | |
21384 | ||
21385 | DEFINITIONS ::= | |
21386 | BEGIN | |
21387 | BERPDU ::= [PRIVATE 1] EXPLICIT NULL | |
21388 | ||
21389 | myNullValue BERPDU ::= NULL | |
21390 | ||
21391 | END | |
21392 | ||
21393 | <STATIC> | |
21394 | ||
21395 | import from TempA all; | |
21396 | ||
21397 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21398 | ||
21399 | ||
21400 | <TTCN_TC:EXEC> | |
21401 | ||
21402 | if (dec_BER_PDU('E1020500'O) == myNullValue) | |
21403 | ||
21404 | ||
21405 | {setverdict(pass);} else {setverdict(fail);} | |
21406 | ||
21407 | ||
21408 | <RESULT> | |
21409 | ||
21410 | Overall verdict: pass | |
21411 | ||
21412 | <END_TC> | |
21413 | ||
21414 | :exmp. | |
21415 | ||
21416 | .*---------------------------------------------------------------------* | |
21417 | :h3. DECODING [PRIVATE 1] EXPLICIT NULL, CER | |
21418 | .*---------------------------------------------------------------------* | |
21419 | :xmp tab=0. | |
21420 | ||
21421 | <TC - DECODING [PRIVATE 1] EXPLICIT NULL, CER> | |
21422 | ||
21423 | <STATIC:ASN> | |
21424 | ||
21425 | TempA | |
21426 | ||
21427 | DEFINITIONS ::= | |
21428 | BEGIN | |
21429 | BERPDU ::= [PRIVATE 1] EXPLICIT NULL | |
21430 | ||
21431 | myNullValue BERPDU ::= NULL | |
21432 | ||
21433 | END | |
21434 | ||
21435 | <STATIC> | |
21436 | ||
21437 | import from TempA all; | |
21438 | ||
21439 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21440 | ||
21441 | ||
21442 | <TTCN_TC:EXEC> | |
21443 | ||
21444 | if (dec_BER_PDU('E18005000000'O) == myNullValue) | |
21445 | ||
21446 | ||
21447 | {setverdict(pass);} else {setverdict(fail);} | |
21448 | ||
21449 | ||
21450 | <RESULT> | |
21451 | ||
21452 | Overall verdict: pass | |
21453 | ||
21454 | <END_TC> | |
21455 | ||
21456 | :exmp. | |
21457 | ||
21458 | .*---------------------------------------------------------------------* | |
21459 | :h3. DECODING [PRIVATE 1] EXPLICIT NULL, Short form - short form | |
21460 | .*---------------------------------------------------------------------* | |
21461 | :xmp tab=0. | |
21462 | ||
21463 | <TC - DECODING [PRIVATE 1] EXPLICIT NULL, Short form - short form> | |
21464 | ||
21465 | <STATIC:ASN> | |
21466 | ||
21467 | TempA | |
21468 | ||
21469 | DEFINITIONS ::= | |
21470 | BEGIN | |
21471 | BERPDU ::= [PRIVATE 1] EXPLICIT NULL | |
21472 | ||
21473 | myNullValue BERPDU ::= NULL | |
21474 | ||
21475 | END | |
21476 | ||
21477 | <STATIC> | |
21478 | ||
21479 | import from TempA all; | |
21480 | ||
21481 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21482 | ||
21483 | ||
21484 | <TTCN_TC:EXEC> | |
21485 | ||
21486 | if (dec_BER_PDU('E1020500'O) == myNullValue) | |
21487 | ||
21488 | ||
21489 | {setverdict(pass);} else {setverdict(fail);} | |
21490 | ||
21491 | ||
21492 | <RESULT> | |
21493 | ||
21494 | Overall verdict: pass | |
21495 | ||
21496 | <END_TC> | |
21497 | ||
21498 | :exmp. | |
21499 | ||
21500 | .*---------------------------------------------------------------------* | |
21501 | :h3. DECODING [PRIVATE 1] EXPLICIT NULL, Long form - short form | |
21502 | .*---------------------------------------------------------------------* | |
21503 | :xmp tab=0. | |
21504 | ||
21505 | <TC - DECODING [PRIVATE 1] EXPLICIT NULL, Long form - short form> | |
21506 | ||
21507 | <STATIC:ASN> | |
21508 | ||
21509 | TempA | |
21510 | ||
21511 | DEFINITIONS ::= | |
21512 | BEGIN | |
21513 | BERPDU ::= [PRIVATE 1] EXPLICIT NULL | |
21514 | ||
21515 | myNullValue BERPDU ::= NULL | |
21516 | ||
21517 | END | |
21518 | ||
21519 | <STATIC> | |
21520 | ||
21521 | import from TempA all; | |
21522 | ||
21523 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21524 | ||
21525 | ||
21526 | <TTCN_TC:EXEC> | |
21527 | ||
21528 | if (dec_BER_PDU('E181020500'O) == myNullValue) | |
21529 | ||
21530 | ||
21531 | {setverdict(pass);} else {setverdict(fail);} | |
21532 | ||
21533 | ||
21534 | <RESULT> | |
21535 | ||
21536 | Overall verdict: pass | |
21537 | ||
21538 | <END_TC> | |
21539 | ||
21540 | :exmp. | |
21541 | ||
21542 | .*---------------------------------------------------------------------* | |
21543 | :h3. DECODING [PRIVATE 1] EXPLICIT NULL, Long form Long form | |
21544 | .*---------------------------------------------------------------------* | |
21545 | :xmp tab=0. | |
21546 | ||
21547 | <TC - DECODING [PRIVATE 1] EXPLICIT NULL, Long form Long form> | |
21548 | ||
21549 | <STATIC:ASN> | |
21550 | ||
21551 | TempA | |
21552 | ||
21553 | DEFINITIONS ::= | |
21554 | BEGIN | |
21555 | BERPDU ::= [PRIVATE 1] EXPLICIT NULL | |
21556 | ||
21557 | myNullValue BERPDU ::= NULL | |
21558 | ||
21559 | END | |
21560 | ||
21561 | <STATIC> | |
21562 | ||
21563 | import from TempA all; | |
21564 | ||
21565 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21566 | ||
21567 | ||
21568 | <TTCN_TC:EXEC> | |
21569 | ||
21570 | if (dec_BER_PDU('E18103058100'O) == myNullValue) | |
21571 | ||
21572 | ||
21573 | {setverdict(pass);} else {setverdict(fail);} | |
21574 | ||
21575 | ||
21576 | <RESULT> | |
21577 | ||
21578 | Overall verdict: pass | |
21579 | ||
21580 | <END_TC> | |
21581 | ||
21582 | :exmp. | |
21583 | ||
21584 | .*---------------------------------------------------------------------* | |
21585 | :h3. DECODING [APPLICATION 2] EXPLICIT NULL , DER | |
21586 | .*---------------------------------------------------------------------* | |
21587 | :xmp tab=0. | |
21588 | ||
21589 | <TC - DECODING [APPLICATION 2] EXPLICIT NULL , DER> | |
21590 | ||
21591 | <STATIC:ASN> | |
21592 | ||
21593 | TempA | |
21594 | ||
21595 | DEFINITIONS ::= | |
21596 | BEGIN | |
21597 | BERPDU ::= [APPLICATION 2] EXPLICIT NULL | |
21598 | ||
21599 | myNullValue BERPDU ::= NULL | |
21600 | ||
21601 | END | |
21602 | ||
21603 | <STATIC> | |
21604 | ||
21605 | import from TempA all; | |
21606 | ||
21607 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21608 | ||
21609 | ||
21610 | <TTCN_TC:EXEC> | |
21611 | ||
21612 | if (dec_BER_PDU('62020500'O) == myNullValue) | |
21613 | ||
21614 | ||
21615 | {setverdict(pass);} else {setverdict(fail);} | |
21616 | ||
21617 | ||
21618 | <RESULT> | |
21619 | ||
21620 | Overall verdict: pass | |
21621 | ||
21622 | <END_TC> | |
21623 | ||
21624 | :exmp. | |
21625 | ||
21626 | .*---------------------------------------------------------------------* | |
21627 | :h3. DECODING [APPLICATION 2] EXPLICIT NULL, CER | |
21628 | .*---------------------------------------------------------------------* | |
21629 | :xmp tab=0. | |
21630 | ||
21631 | <TC - DECODING [APPLICATION 2] EXPLICIT NULL, CER> | |
21632 | ||
21633 | <STATIC:ASN> | |
21634 | ||
21635 | TempA | |
21636 | ||
21637 | DEFINITIONS ::= | |
21638 | BEGIN | |
21639 | BERPDU ::= [APPLICATION 2] EXPLICIT NULL | |
21640 | ||
21641 | myNullValue BERPDU ::= NULL | |
21642 | ||
21643 | END | |
21644 | ||
21645 | <STATIC> | |
21646 | ||
21647 | import from TempA all; | |
21648 | ||
21649 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21650 | ||
21651 | ||
21652 | <TTCN_TC:EXEC> | |
21653 | ||
21654 | if (dec_BER_PDU('628005000000'O) == myNullValue) | |
21655 | ||
21656 | ||
21657 | {setverdict(pass);} else {setverdict(fail);} | |
21658 | ||
21659 | ||
21660 | <RESULT> | |
21661 | ||
21662 | Overall verdict: pass | |
21663 | ||
21664 | <END_TC> | |
21665 | ||
21666 | :exmp. | |
21667 | ||
21668 | .*---------------------------------------------------------------------* | |
21669 | :h3. DECODING [APPLICATION 2] EXPLICIT NULL, Short form - short form | |
21670 | .*---------------------------------------------------------------------* | |
21671 | :xmp tab=0. | |
21672 | ||
21673 | <TC - DECODING [APPLICATION 2] EXPLICIT NULL, Short form - short form> | |
21674 | ||
21675 | <STATIC:ASN> | |
21676 | ||
21677 | TempA | |
21678 | ||
21679 | DEFINITIONS ::= | |
21680 | BEGIN | |
21681 | BERPDU ::= [APPLICATION 2] EXPLICIT NULL | |
21682 | ||
21683 | myNullValue BERPDU ::= NULL | |
21684 | ||
21685 | END | |
21686 | ||
21687 | <STATIC> | |
21688 | ||
21689 | import from TempA all; | |
21690 | ||
21691 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21692 | ||
21693 | ||
21694 | <TTCN_TC:EXEC> | |
21695 | ||
21696 | if (dec_BER_PDU('62020500'O) == myNullValue) | |
21697 | ||
21698 | ||
21699 | {setverdict(pass);} else {setverdict(fail);} | |
21700 | ||
21701 | ||
21702 | <RESULT> | |
21703 | ||
21704 | Overall verdict: pass | |
21705 | ||
21706 | <END_TC> | |
21707 | ||
21708 | :exmp. | |
21709 | ||
21710 | .*---------------------------------------------------------------------* | |
21711 | :h3. DECODING [APPLICATION 2] EXPLICIT NULL, Long form - short form | |
21712 | .*---------------------------------------------------------------------* | |
21713 | :xmp tab=0. | |
21714 | ||
21715 | <TC - DECODING [APPLICATION 2] EXPLICIT NULL, Long form - short form> | |
21716 | ||
21717 | <STATIC:ASN> | |
21718 | ||
21719 | TempA | |
21720 | ||
21721 | DEFINITIONS ::= | |
21722 | BEGIN | |
21723 | BERPDU ::= [APPLICATION 2] EXPLICIT NULL | |
21724 | ||
21725 | myNullValue BERPDU ::= NULL | |
21726 | ||
21727 | END | |
21728 | ||
21729 | <STATIC> | |
21730 | ||
21731 | import from TempA all; | |
21732 | ||
21733 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21734 | ||
21735 | ||
21736 | <TTCN_TC:EXEC> | |
21737 | ||
21738 | if (dec_BER_PDU('6281020500'O) == myNullValue) | |
21739 | ||
21740 | ||
21741 | {setverdict(pass);} else {setverdict(fail);} | |
21742 | ||
21743 | ||
21744 | <RESULT> | |
21745 | ||
21746 | Overall verdict: pass | |
21747 | ||
21748 | <END_TC> | |
21749 | ||
21750 | :exmp. | |
21751 | ||
21752 | .*---------------------------------------------------------------------* | |
21753 | :h3. DECODING [APPLICATION 2] EXPLICIT NULL, Long form Long form | |
21754 | .*---------------------------------------------------------------------* | |
21755 | :xmp tab=0. | |
21756 | ||
21757 | <TC - DECODING [APPLICATION 2] EXPLICIT NULL, Long form Long form> | |
21758 | ||
21759 | <STATIC:ASN> | |
21760 | ||
21761 | TempA | |
21762 | ||
21763 | DEFINITIONS ::= | |
21764 | BEGIN | |
21765 | BERPDU ::= [APPLICATION 2] EXPLICIT NULL | |
21766 | ||
21767 | myNullValue BERPDU ::= NULL | |
21768 | ||
21769 | END | |
21770 | ||
21771 | <STATIC> | |
21772 | ||
21773 | import from TempA all; | |
21774 | ||
21775 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21776 | ||
21777 | ||
21778 | <TTCN_TC:EXEC> | |
21779 | ||
21780 | if (dec_BER_PDU('628103058100'O) == myNullValue) | |
21781 | ||
21782 | ||
21783 | {setverdict(pass);} else {setverdict(fail);} | |
21784 | ||
21785 | ||
21786 | <RESULT> | |
21787 | ||
21788 | Overall verdict: pass | |
21789 | ||
21790 | <END_TC> | |
21791 | ||
21792 | :exmp. | |
21793 | ||
21794 | .*---------------------------------------------------------------------* | |
21795 | :h3. DECODING [0] IMPLICIT NULL ,Short form CER,DER | |
21796 | .*---------------------------------------------------------------------* | |
21797 | :xmp tab=0. | |
21798 | ||
21799 | <TC - DECODING [0] IMPLICIT NULL ,Short form CER,DER> | |
21800 | ||
21801 | <STATIC:ASN> | |
21802 | ||
21803 | TempA | |
21804 | ||
21805 | DEFINITIONS ::= | |
21806 | BEGIN | |
21807 | BERPDU ::= [0] IMPLICIT NULL | |
21808 | ||
21809 | myNullValue BERPDU ::= NULL | |
21810 | ||
21811 | END | |
21812 | ||
21813 | <STATIC> | |
21814 | ||
21815 | import from TempA all; | |
21816 | ||
21817 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21818 | ||
21819 | ||
21820 | <TTCN_TC:EXEC> | |
21821 | ||
21822 | if (dec_BER_PDU('8000'O) == myNullValue) | |
21823 | ||
21824 | ||
21825 | {setverdict(pass);} else {setverdict(fail);} | |
21826 | ||
21827 | ||
21828 | <RESULT> | |
21829 | ||
21830 | Overall verdict: pass | |
21831 | ||
21832 | <END_TC> | |
21833 | ||
21834 | :exmp. | |
21835 | ||
21836 | .*---------------------------------------------------------------------* | |
21837 | :h3. DECODING [0] IMPLICIT NULL ,Long form | |
21838 | .*---------------------------------------------------------------------* | |
21839 | :xmp tab=0. | |
21840 | ||
21841 | <TC - DECODING [0] IMPLICIT NULL ,Long form> | |
21842 | ||
21843 | <STATIC:ASN> | |
21844 | ||
21845 | TempA | |
21846 | ||
21847 | DEFINITIONS ::= | |
21848 | BEGIN | |
21849 | BERPDU ::= [0] IMPLICIT NULL | |
21850 | ||
21851 | myNullValue BERPDU ::= NULL | |
21852 | ||
21853 | END | |
21854 | ||
21855 | <STATIC> | |
21856 | ||
21857 | import from TempA all; | |
21858 | ||
21859 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21860 | ||
21861 | ||
21862 | <TTCN_TC:EXEC> | |
21863 | ||
21864 | if (dec_BER_PDU('808100'O) == myNullValue) | |
21865 | ||
21866 | ||
21867 | {setverdict(pass);} else {setverdict(fail);} | |
21868 | ||
21869 | ||
21870 | <RESULT> | |
21871 | ||
21872 | Overall verdict: pass | |
21873 | ||
21874 | <END_TC> | |
21875 | ||
21876 | :exmp. | |
21877 | ||
21878 | .*---------------------------------------------------------------------* | |
21879 | :h3. DECODING [PRIVATE 1] IMPLICIT NULL ,Short form CER,DER | |
21880 | .*---------------------------------------------------------------------* | |
21881 | :xmp tab=0. | |
21882 | ||
21883 | <TC - DECODING [PRIVATE 1] IMPLICIT NULL ,Short form CER,DER> | |
21884 | ||
21885 | <STATIC:ASN> | |
21886 | ||
21887 | TempA | |
21888 | ||
21889 | DEFINITIONS ::= | |
21890 | BEGIN | |
21891 | BERPDU ::= [PRIVATE 1] IMPLICIT NULL | |
21892 | ||
21893 | myNullValue BERPDU ::= NULL | |
21894 | ||
21895 | END | |
21896 | ||
21897 | <STATIC> | |
21898 | ||
21899 | import from TempA all; | |
21900 | ||
21901 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21902 | ||
21903 | ||
21904 | <TTCN_TC:EXEC> | |
21905 | ||
21906 | if (dec_BER_PDU('C100'O) == myNullValue) | |
21907 | ||
21908 | ||
21909 | {setverdict(pass);} else {setverdict(fail);} | |
21910 | ||
21911 | ||
21912 | <RESULT> | |
21913 | ||
21914 | Overall verdict: pass | |
21915 | ||
21916 | <END_TC> | |
21917 | ||
21918 | :exmp. | |
21919 | ||
21920 | .*---------------------------------------------------------------------* | |
21921 | :h3. DECODING [PRIVATE 1] IMPLICIT NULL ,Long form | |
21922 | .*---------------------------------------------------------------------* | |
21923 | :xmp tab=0. | |
21924 | ||
21925 | <TC - DECODING [PRIVATE 1] IMPLICIT NULL ,Long form> | |
21926 | ||
21927 | <STATIC:ASN> | |
21928 | ||
21929 | TempA | |
21930 | ||
21931 | DEFINITIONS ::= | |
21932 | BEGIN | |
21933 | BERPDU ::= [PRIVATE 1] IMPLICIT NULL | |
21934 | ||
21935 | myNullValue BERPDU ::= NULL | |
21936 | ||
21937 | END | |
21938 | ||
21939 | <STATIC> | |
21940 | ||
21941 | import from TempA all; | |
21942 | ||
21943 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21944 | ||
21945 | ||
21946 | <TTCN_TC:EXEC> | |
21947 | ||
21948 | if (dec_BER_PDU('C18100'O) == myNullValue) | |
21949 | ||
21950 | ||
21951 | {setverdict(pass);} else {setverdict(fail);} | |
21952 | ||
21953 | ||
21954 | <RESULT> | |
21955 | ||
21956 | Overall verdict: pass | |
21957 | ||
21958 | <END_TC> | |
21959 | ||
21960 | :exmp. | |
21961 | ||
21962 | .*---------------------------------------------------------------------* | |
21963 | :h3. DECODING [APPLICATION 2] IMPLICIT NULL ,Short form CER,DER | |
21964 | .*---------------------------------------------------------------------* | |
21965 | :xmp tab=0. | |
21966 | ||
21967 | <TC - DECODING [APPLICATION 2] IMPLICIT NULL ,Short form CER,DER> | |
21968 | ||
21969 | <STATIC:ASN> | |
21970 | ||
21971 | TempA | |
21972 | ||
21973 | DEFINITIONS ::= | |
21974 | BEGIN | |
21975 | BERPDU ::= [APPLICATION 2] IMPLICIT NULL | |
21976 | ||
21977 | myNullValue BERPDU ::= NULL | |
21978 | ||
21979 | END | |
21980 | ||
21981 | <STATIC> | |
21982 | ||
21983 | import from TempA all; | |
21984 | ||
21985 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
21986 | ||
21987 | ||
21988 | <TTCN_TC:EXEC> | |
21989 | ||
21990 | if (dec_BER_PDU('4200'O) == myNullValue) | |
21991 | ||
21992 | ||
21993 | {setverdict(pass);} else {setverdict(fail);} | |
21994 | ||
21995 | ||
21996 | <RESULT> | |
21997 | ||
21998 | Overall verdict: pass | |
21999 | ||
22000 | <END_TC> | |
22001 | ||
22002 | :exmp. | |
22003 | ||
22004 | .*---------------------------------------------------------------------* | |
22005 | :h3. DECODING [APPLICATION 2] IMPLICIT NULL,Long form | |
22006 | .*---------------------------------------------------------------------* | |
22007 | :xmp tab=0. | |
22008 | ||
22009 | <TC - DECODING [APPLICATION 2] IMPLICIT NULL,Long form> | |
22010 | ||
22011 | <STATIC:ASN> | |
22012 | ||
22013 | TempA | |
22014 | ||
22015 | DEFINITIONS ::= | |
22016 | BEGIN | |
22017 | BERPDU ::= [APPLICATION 2] IMPLICIT NULL | |
22018 | ||
22019 | myNullValue BERPDU ::= NULL | |
22020 | ||
22021 | END | |
22022 | ||
22023 | <STATIC> | |
22024 | ||
22025 | import from TempA all; | |
22026 | ||
22027 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
22028 | ||
22029 | ||
22030 | <TTCN_TC:EXEC> | |
22031 | ||
22032 | if (dec_BER_PDU('428100'O) == myNullValue) | |
22033 | ||
22034 | ||
22035 | {setverdict(pass);} else {setverdict(fail);} | |
22036 | ||
22037 | ||
22038 | <RESULT> | |
22039 | ||
22040 | Overall verdict: pass | |
22041 | ||
22042 | <END_TC> | |
22043 | ||
22044 | :exmp. | |
22045 | ||
22046 | .*---------------------------------------------------------------------* | |
22047 | :h3.CER + DER encoding of SEQUENCE (EMPTY) | |
22048 | .*---------------------------------------------------------------------* | |
22049 | :xmp tab=0. | |
22050 | ||
22051 | <TC - CER + DER encoding of SEQUENCE (EMPTY)> | |
22052 | ||
22053 | <STATIC:ASN> | |
22054 | ||
22055 | TempA | |
22056 | ||
22057 | DEFINITIONS ::= | |
22058 | BEGIN | |
22059 | ||
22060 | BERPDU ::= SEQUENCE | |
22061 | { | |
22062 | b BOOLEAN OPTIONAL, | |
22063 | c INTEGER OPTIONAL | |
22064 | } | |
22065 | ||
22066 | ||
22067 | END | |
22068 | ||
22069 | <STATIC> | |
22070 | ||
22071 | import from TempA all; | |
22072 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22073 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22074 | ||
22075 | const BERPDU myValue := {b := omit, | |
22076 | c := omit } | |
22077 | ||
22078 | <TTCN_TC:EXEC> | |
22079 | ||
22080 | ||
22081 | ||
22082 | ||
22083 | if ((enc_DER_PDU(myValue) == '3000'O)and(enc_CER_PDU(myValue) == '30800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22084 | ||
22085 | <RESULT> | |
22086 | ||
22087 | Overall verdict: pass | |
22088 | ||
22089 | <END_TC> | |
22090 | ||
22091 | :exmp. | |
22092 | ||
22093 | .*---------------------------------------------------------------------* | |
22094 | :h3.CER + DER encoding of SEQUENCE (only one element is used) | |
22095 | .*---------------------------------------------------------------------* | |
22096 | :xmp tab=0. | |
22097 | ||
22098 | <TC - CER + DER encoding of SEQUENCE (only one element is used)> | |
22099 | ||
22100 | <STATIC:ASN> | |
22101 | ||
22102 | TempA | |
22103 | ||
22104 | DEFINITIONS ::= | |
22105 | BEGIN | |
22106 | ||
22107 | BERPDU ::= SEQUENCE | |
22108 | { | |
22109 | b BOOLEAN OPTIONAL, | |
22110 | c INTEGER OPTIONAL | |
22111 | } | |
22112 | ||
22113 | ||
22114 | END | |
22115 | ||
22116 | <STATIC> | |
22117 | ||
22118 | import from TempA all; | |
22119 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22120 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22121 | ||
22122 | const BERPDU myValue := {b := true, | |
22123 | c := omit } | |
22124 | ||
22125 | <TTCN_TC:EXEC> | |
22126 | ||
22127 | ||
22128 | ||
22129 | ||
22130 | if ((enc_DER_PDU(myValue) == '30030101FF'O)and(enc_CER_PDU(myValue) == '30800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22131 | ||
22132 | <RESULT> | |
22133 | ||
22134 | Overall verdict: pass | |
22135 | ||
22136 | <END_TC> | |
22137 | ||
22138 | :exmp. | |
22139 | ||
22140 | .*---------------------------------------------------------------------* | |
22141 | :h3.CER + DER encoding of SEQUENCE (both elements are used) | |
22142 | .*---------------------------------------------------------------------* | |
22143 | :xmp tab=0. | |
22144 | ||
22145 | <TC - CER + DER encoding of SEQUENCE (both elements are used)> | |
22146 | ||
22147 | <STATIC:ASN> | |
22148 | ||
22149 | TempA | |
22150 | ||
22151 | DEFINITIONS ::= | |
22152 | BEGIN | |
22153 | ||
22154 | BERPDU ::= SEQUENCE | |
22155 | { | |
22156 | b BOOLEAN OPTIONAL, | |
22157 | c INTEGER OPTIONAL | |
22158 | } | |
22159 | ||
22160 | ||
22161 | END | |
22162 | ||
22163 | <STATIC> | |
22164 | ||
22165 | import from TempA all; | |
22166 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22167 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22168 | ||
22169 | const BERPDU myValue := {b := true, | |
22170 | c := 5 } | |
22171 | ||
22172 | <TTCN_TC:EXEC> | |
22173 | ||
22174 | ||
22175 | ||
22176 | ||
22177 | if ((enc_DER_PDU(myValue) == '30060101FF020105'O)and(enc_CER_PDU(myValue) == '30800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22178 | ||
22179 | <RESULT> | |
22180 | ||
22181 | Overall verdict: pass | |
22182 | ||
22183 | <END_TC> | |
22184 | ||
22185 | :exmp. | |
22186 | ||
22187 | .*---------------------------------------------------------------------* | |
22188 | :h3.CER + DER encoding of SEQUENCE (one element is equal to Default) | |
22189 | .*---------------------------------------------------------------------* | |
22190 | :xmp tab=0. | |
22191 | ||
22192 | <TC - CER + DER encoding of SEQUENCE (one element is equal to Default)> | |
22193 | ||
22194 | <STATIC:ASN> | |
22195 | ||
22196 | TempA | |
22197 | ||
22198 | DEFINITIONS ::= | |
22199 | BEGIN | |
22200 | ||
22201 | BERPDU ::= SEQUENCE | |
22202 | { | |
22203 | b BOOLEAN DEFAULT TRUE, | |
22204 | c INTEGER OPTIONAL | |
22205 | } | |
22206 | ||
22207 | ||
22208 | END | |
22209 | ||
22210 | <STATIC> | |
22211 | ||
22212 | import from TempA all; | |
22213 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22214 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22215 | ||
22216 | const BERPDU myValue := {b := true, | |
22217 | c := 5 } | |
22218 | ||
22219 | <TTCN_TC:EXEC> | |
22220 | ||
22221 | ||
22222 | ||
22223 | ||
22224 | if ((enc_DER_PDU(myValue) == '3003020105'O)and(enc_CER_PDU(myValue) == '30800201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22225 | ||
22226 | <RESULT> | |
22227 | ||
22228 | Overall verdict: pass | |
22229 | ||
22230 | <END_TC> | |
22231 | ||
22232 | :exmp. | |
22233 | ||
22234 | .*---------------------------------------------------------------------* | |
22235 | :h3.CER + DER encoding of SEQUENCE (one element is not equal to Default) | |
22236 | .*---------------------------------------------------------------------* | |
22237 | :xmp tab=0. | |
22238 | ||
22239 | <TC - CER + DER encoding of SEQUENCE (one element is not equal to Default)> | |
22240 | ||
22241 | <STATIC:ASN> | |
22242 | ||
22243 | TempA | |
22244 | ||
22245 | DEFINITIONS ::= | |
22246 | BEGIN | |
22247 | ||
22248 | BERPDU ::= SEQUENCE | |
22249 | { | |
22250 | b BOOLEAN DEFAULT TRUE, | |
22251 | c INTEGER OPTIONAL | |
22252 | } | |
22253 | ||
22254 | ||
22255 | END | |
22256 | ||
22257 | <STATIC> | |
22258 | ||
22259 | import from TempA all; | |
22260 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22261 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22262 | ||
22263 | const BERPDU myValue := {b := false, | |
22264 | c := 5 } | |
22265 | ||
22266 | <TTCN_TC:EXEC> | |
22267 | ||
22268 | ||
22269 | ||
22270 | ||
22271 | if ((enc_DER_PDU(myValue) == '3006010100020105'O)and(enc_CER_PDU(myValue) == '30800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22272 | ||
22273 | <RESULT> | |
22274 | ||
22275 | Overall verdict: pass | |
22276 | ||
22277 | <END_TC> | |
22278 | ||
22279 | :exmp. | |
22280 | ||
22281 | .*---------------------------------------------------------------------* | |
22282 | :h3.CER + DER encoding of SEQUENCE (EMPTY), AUTOMATIC TAGGING | |
22283 | .*---------------------------------------------------------------------* | |
22284 | :xmp tab=0. | |
22285 | ||
22286 | <TC - CER + DER encoding of SEQUENCE (EMPTY), AUTOMATIC TAGGING> | |
22287 | ||
22288 | <STATIC:ASN> | |
22289 | ||
22290 | TempA | |
22291 | ||
22292 | DEFINITIONS | |
22293 | ||
22294 | AUTOMATIC TAGS | |
22295 | ||
22296 | ::= | |
22297 | ||
22298 | BEGIN | |
22299 | ||
22300 | BERPDU ::= SEQUENCE | |
22301 | { | |
22302 | b BOOLEAN OPTIONAL, | |
22303 | c INTEGER OPTIONAL | |
22304 | } | |
22305 | ||
22306 | ||
22307 | END | |
22308 | ||
22309 | <STATIC> | |
22310 | ||
22311 | import from TempA all; | |
22312 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22313 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22314 | ||
22315 | const BERPDU myValue := {b := omit, | |
22316 | c := omit } | |
22317 | ||
22318 | <TTCN_TC:EXEC> | |
22319 | ||
22320 | ||
22321 | ||
22322 | ||
22323 | if ((enc_DER_PDU(myValue) == '3000'O)and(enc_CER_PDU(myValue) == '30800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22324 | ||
22325 | <RESULT> | |
22326 | ||
22327 | Overall verdict: pass | |
22328 | ||
22329 | <END_TC> | |
22330 | ||
22331 | :exmp. | |
22332 | ||
22333 | .*---------------------------------------------------------------------* | |
22334 | :h3.CER + DER encoding of SEQUENCE (only one element is used) AUTOMATIC TAGGING | |
22335 | .*---------------------------------------------------------------------* | |
22336 | :xmp tab=0. | |
22337 | ||
22338 | <TC - CER + DER encoding of SEQUENCE (only one element is used) AUTOMATIC TAGGING> | |
22339 | ||
22340 | <STATIC:ASN> | |
22341 | ||
22342 | TempA | |
22343 | ||
22344 | DEFINITIONS | |
22345 | ||
22346 | AUTOMATIC TAGS | |
22347 | ||
22348 | ::= | |
22349 | ||
22350 | BEGIN | |
22351 | ||
22352 | BERPDU ::= SEQUENCE | |
22353 | { | |
22354 | b BOOLEAN OPTIONAL, | |
22355 | c INTEGER OPTIONAL | |
22356 | } | |
22357 | ||
22358 | ||
22359 | END | |
22360 | ||
22361 | <STATIC> | |
22362 | ||
22363 | import from TempA all; | |
22364 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22365 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22366 | ||
22367 | const BERPDU myValue := {b := true, | |
22368 | c := omit } | |
22369 | ||
22370 | <TTCN_TC:EXEC> | |
22371 | ||
22372 | ||
22373 | ||
22374 | ||
22375 | if ((enc_DER_PDU(myValue) == '30038001FF'O)and(enc_CER_PDU(myValue) == '30808001FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22376 | ||
22377 | <RESULT> | |
22378 | ||
22379 | Overall verdict: pass | |
22380 | ||
22381 | <END_TC> | |
22382 | ||
22383 | :exmp. | |
22384 | ||
22385 | .*---------------------------------------------------------------------* | |
22386 | :h3.CER + DER encoding of SEQUENCE (both elements are used) AUTOMATIC TAGGING | |
22387 | .*---------------------------------------------------------------------* | |
22388 | :xmp tab=0. | |
22389 | ||
22390 | <TC - CER + DER encoding of SEQUENCE (both elements are used) AUTOMATIC TAGGING> | |
22391 | ||
22392 | <STATIC:ASN> | |
22393 | ||
22394 | TempA | |
22395 | ||
22396 | DEFINITIONS | |
22397 | ||
22398 | AUTOMATIC TAGS | |
22399 | ||
22400 | ::= | |
22401 | ||
22402 | BEGIN | |
22403 | ||
22404 | BERPDU ::= SEQUENCE | |
22405 | { | |
22406 | b BOOLEAN OPTIONAL, | |
22407 | c INTEGER OPTIONAL | |
22408 | } | |
22409 | ||
22410 | ||
22411 | END | |
22412 | ||
22413 | <STATIC> | |
22414 | ||
22415 | import from TempA all; | |
22416 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22417 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22418 | ||
22419 | const BERPDU myValue := {b := true, | |
22420 | c := 5 } | |
22421 | ||
22422 | <TTCN_TC:EXEC> | |
22423 | ||
22424 | ||
22425 | ||
22426 | ||
22427 | if ((enc_DER_PDU(myValue) == '30068001FF810105'O)and(enc_CER_PDU(myValue) == '30808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22428 | ||
22429 | <RESULT> | |
22430 | ||
22431 | Overall verdict: pass | |
22432 | ||
22433 | <END_TC> | |
22434 | ||
22435 | :exmp. | |
22436 | ||
22437 | .*---------------------------------------------------------------------* | |
22438 | :h3.CER + DER encoding of SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING | |
22439 | .*---------------------------------------------------------------------* | |
22440 | :xmp tab=0. | |
22441 | ||
22442 | <TC - CER + DER encoding of SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING> | |
22443 | ||
22444 | <STATIC:ASN> | |
22445 | ||
22446 | TempA | |
22447 | ||
22448 | DEFINITIONS | |
22449 | ||
22450 | AUTOMATIC TAGS | |
22451 | ||
22452 | ::= | |
22453 | ||
22454 | BEGIN | |
22455 | ||
22456 | BERPDU ::= SEQUENCE | |
22457 | { | |
22458 | b BOOLEAN DEFAULT TRUE, | |
22459 | c INTEGER OPTIONAL | |
22460 | } | |
22461 | ||
22462 | ||
22463 | END | |
22464 | ||
22465 | <STATIC> | |
22466 | ||
22467 | import from TempA all; | |
22468 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22469 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22470 | ||
22471 | const BERPDU myValue := {b := true, | |
22472 | c := 5 } | |
22473 | ||
22474 | <TTCN_TC:EXEC> | |
22475 | ||
22476 | ||
22477 | ||
22478 | ||
22479 | if ((enc_DER_PDU(myValue) == '3003810105'O)and(enc_CER_PDU(myValue) == '30808101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22480 | ||
22481 | <RESULT> | |
22482 | ||
22483 | Overall verdict: pass | |
22484 | ||
22485 | <END_TC> | |
22486 | ||
22487 | :exmp. | |
22488 | ||
22489 | .*---------------------------------------------------------------------* | |
22490 | :h3.CER + DER encoding of SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING | |
22491 | .*---------------------------------------------------------------------* | |
22492 | :xmp tab=0. | |
22493 | ||
22494 | <TC - CER + DER encoding of SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING> | |
22495 | ||
22496 | <STATIC:ASN> | |
22497 | ||
22498 | TempA | |
22499 | ||
22500 | DEFINITIONS | |
22501 | ||
22502 | AUTOMATIC TAGS | |
22503 | ||
22504 | ::= | |
22505 | ||
22506 | BEGIN | |
22507 | ||
22508 | BERPDU ::= SEQUENCE | |
22509 | { | |
22510 | b BOOLEAN DEFAULT TRUE, | |
22511 | c INTEGER OPTIONAL | |
22512 | } | |
22513 | ||
22514 | ||
22515 | END | |
22516 | ||
22517 | <STATIC> | |
22518 | ||
22519 | import from TempA all; | |
22520 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22521 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22522 | ||
22523 | const BERPDU myValue := {b := false, | |
22524 | c := 5 } | |
22525 | ||
22526 | <TTCN_TC:EXEC> | |
22527 | ||
22528 | ||
22529 | ||
22530 | ||
22531 | if ((enc_DER_PDU(myValue) == '3006800100810105'O)and(enc_CER_PDU(myValue) == '30808001008101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22532 | ||
22533 | <RESULT> | |
22534 | ||
22535 | Overall verdict: pass | |
22536 | ||
22537 | <END_TC> | |
22538 | ||
22539 | :exmp. | |
22540 | ||
22541 | .*---------------------------------------------------------------------* | |
22542 | :h3.CER + DER encoding of SEQUENCE (both elements are used) IMPLICIT TAGS for elements | |
22543 | .*---------------------------------------------------------------------* | |
22544 | :xmp tab=0. | |
22545 | ||
22546 | <TC - CER + DER encoding of SEQUENCE (both elements are used) IMPLICIT TAGS for elements> | |
22547 | ||
22548 | <STATIC:ASN> | |
22549 | ||
22550 | TempA | |
22551 | ||
22552 | DEFINITIONS ::= | |
22553 | BEGIN | |
22554 | ||
22555 | BERPDU ::= SEQUENCE | |
22556 | { | |
22557 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
22558 | c [31] IMPLICIT INTEGER OPTIONAL | |
22559 | } | |
22560 | ||
22561 | ||
22562 | END | |
22563 | ||
22564 | <STATIC> | |
22565 | ||
22566 | import from TempA all; | |
22567 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22568 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22569 | ||
22570 | const BERPDU myValue := {b := true, | |
22571 | c := 5 } | |
22572 | ||
22573 | <TTCN_TC:EXEC> | |
22574 | ||
22575 | ||
22576 | ||
22577 | ||
22578 | if ((enc_DER_PDU(myValue) == '30079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '30809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22579 | ||
22580 | <RESULT> | |
22581 | ||
22582 | Overall verdict: pass | |
22583 | ||
22584 | <END_TC> | |
22585 | ||
22586 | :exmp. | |
22587 | ||
22588 | .*---------------------------------------------------------------------* | |
22589 | :h3.CER + DER encoding of SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT | |
22590 | .*---------------------------------------------------------------------* | |
22591 | :xmp tab=0. | |
22592 | ||
22593 | <TC - CER + DER encoding of SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT> | |
22594 | ||
22595 | <STATIC:ASN> | |
22596 | ||
22597 | TempA | |
22598 | ||
22599 | DEFINITIONS | |
22600 | ||
22601 | EXPLICIT TAGS | |
22602 | ||
22603 | ::= | |
22604 | ||
22605 | BEGIN | |
22606 | ||
22607 | BERPDU ::= SEQUENCE | |
22608 | { | |
22609 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
22610 | c [31] IMPLICIT INTEGER OPTIONAL | |
22611 | } | |
22612 | ||
22613 | ||
22614 | END | |
22615 | ||
22616 | <STATIC> | |
22617 | ||
22618 | import from TempA all; | |
22619 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22620 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22621 | ||
22622 | const BERPDU myValue := {b := true, | |
22623 | c := 5 } | |
22624 | ||
22625 | <TTCN_TC:EXEC> | |
22626 | ||
22627 | ||
22628 | ||
22629 | ||
22630 | if ((enc_DER_PDU(myValue) == '30079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '30809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22631 | ||
22632 | <RESULT> | |
22633 | ||
22634 | Overall verdict: pass | |
22635 | ||
22636 | <END_TC> | |
22637 | ||
22638 | :exmp. | |
22639 | ||
22640 | .*---------------------------------------------------------------------* | |
22641 | :h3.CER + DER encoding of SEQUENCE (both elements are used) EXPLICIT TAGS for elements | |
22642 | .*---------------------------------------------------------------------* | |
22643 | :xmp tab=0. | |
22644 | ||
22645 | <TC - CER + DER encoding of SEQUENCE (both elements are used) EXPLICIT TAGS for elements> | |
22646 | ||
22647 | <STATIC:ASN> | |
22648 | ||
22649 | TempA | |
22650 | ||
22651 | DEFINITIONS ::= | |
22652 | BEGIN | |
22653 | ||
22654 | BERPDU ::= SEQUENCE | |
22655 | { | |
22656 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
22657 | c [31] EXPLICIT INTEGER OPTIONAL | |
22658 | } | |
22659 | ||
22660 | ||
22661 | END | |
22662 | ||
22663 | <STATIC> | |
22664 | ||
22665 | import from TempA all; | |
22666 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22667 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22668 | ||
22669 | const BERPDU myValue := {b := true, | |
22670 | c := 5 } | |
22671 | ||
22672 | <TTCN_TC:EXEC> | |
22673 | ||
22674 | ||
22675 | ||
22676 | ||
22677 | if ((enc_DER_PDU(myValue) == '300BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3080BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22678 | ||
22679 | <RESULT> | |
22680 | ||
22681 | Overall verdict: pass | |
22682 | ||
22683 | <END_TC> | |
22684 | ||
22685 | :exmp. | |
22686 | ||
22687 | .*---------------------------------------------------------------------* | |
22688 | :h3.CER + DER encoding of SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT | |
22689 | .*---------------------------------------------------------------------* | |
22690 | :xmp tab=0. | |
22691 | ||
22692 | <TC - CER + DER encoding of SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT> | |
22693 | ||
22694 | <STATIC:ASN> | |
22695 | ||
22696 | TempA | |
22697 | ||
22698 | DEFINITIONS | |
22699 | ||
22700 | IMPLICIT TAGS | |
22701 | ||
22702 | ::= | |
22703 | ||
22704 | BEGIN | |
22705 | ||
22706 | BERPDU ::= SEQUENCE | |
22707 | { | |
22708 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
22709 | c [31] EXPLICIT INTEGER OPTIONAL | |
22710 | } | |
22711 | ||
22712 | ||
22713 | END | |
22714 | ||
22715 | <STATIC> | |
22716 | ||
22717 | import from TempA all; | |
22718 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22719 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22720 | ||
22721 | const BERPDU myValue := {b := true, | |
22722 | c := 5 } | |
22723 | ||
22724 | <TTCN_TC:EXEC> | |
22725 | ||
22726 | ||
22727 | ||
22728 | ||
22729 | if ((enc_DER_PDU(myValue) == '300BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3080BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22730 | ||
22731 | <RESULT> | |
22732 | ||
22733 | Overall verdict: pass | |
22734 | ||
22735 | <END_TC> | |
22736 | ||
22737 | :exmp. | |
22738 | ||
22739 | .*---------------------------------------------------------------------* | |
22740 | :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are used) | |
22741 | .*---------------------------------------------------------------------* | |
22742 | :xmp tab=0. | |
22743 | ||
22744 | <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are used)> | |
22745 | ||
22746 | <STATIC:ASN> | |
22747 | ||
22748 | TempA | |
22749 | ||
22750 | DEFINITIONS ::= | |
22751 | BEGIN | |
22752 | ||
22753 | BERPDU ::= [0] SEQUENCE | |
22754 | { | |
22755 | b BOOLEAN OPTIONAL, | |
22756 | c INTEGER OPTIONAL | |
22757 | } | |
22758 | ||
22759 | ||
22760 | END | |
22761 | ||
22762 | <STATIC> | |
22763 | ||
22764 | import from TempA all; | |
22765 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22766 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22767 | ||
22768 | const BERPDU myValue := {b := true, | |
22769 | c := 5 } | |
22770 | ||
22771 | <TTCN_TC:EXEC> | |
22772 | ||
22773 | ||
22774 | ||
22775 | ||
22776 | if ((enc_DER_PDU(myValue) == 'A00830060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08030800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22777 | ||
22778 | <RESULT> | |
22779 | ||
22780 | Overall verdict: pass | |
22781 | ||
22782 | <END_TC> | |
22783 | ||
22784 | :exmp. | |
22785 | ||
22786 | .*---------------------------------------------------------------------* | |
22787 | :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are used), AUTOMATIC TAGGING ENVIRONMENT | |
22788 | .*---------------------------------------------------------------------* | |
22789 | :xmp tab=0. | |
22790 | ||
22791 | <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are used), AUTOMATIC TAGGING ENVIRONMENT> | |
22792 | ||
22793 | <STATIC:ASN> | |
22794 | ||
22795 | TempA | |
22796 | ||
22797 | DEFINITIONS | |
22798 | ||
22799 | AUTOMATIC TAGS | |
22800 | ||
22801 | ::= | |
22802 | ||
22803 | BEGIN | |
22804 | ||
22805 | BERPDU ::= [0] SEQUENCE | |
22806 | { | |
22807 | b BOOLEAN OPTIONAL, | |
22808 | c INTEGER OPTIONAL | |
22809 | } | |
22810 | ||
22811 | ||
22812 | END | |
22813 | ||
22814 | <STATIC> | |
22815 | ||
22816 | import from TempA all; | |
22817 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22818 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22819 | ||
22820 | const BERPDU myValue := {b := true, | |
22821 | c := 5 } | |
22822 | ||
22823 | <TTCN_TC:EXEC> | |
22824 | ||
22825 | ||
22826 | ||
22827 | ||
22828 | if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22829 | ||
22830 | <RESULT> | |
22831 | ||
22832 | Overall verdict: pass | |
22833 | ||
22834 | <END_TC> | |
22835 | ||
22836 | :exmp. | |
22837 | ||
22838 | .*---------------------------------------------------------------------* | |
22839 | :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT | |
22840 | .*---------------------------------------------------------------------* | |
22841 | :xmp tab=0. | |
22842 | ||
22843 | <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT> | |
22844 | ||
22845 | <STATIC:ASN> | |
22846 | ||
22847 | TempA | |
22848 | ||
22849 | DEFINITIONS | |
22850 | ||
22851 | IMPLICIT TAGS | |
22852 | ||
22853 | ::= | |
22854 | ||
22855 | BEGIN | |
22856 | ||
22857 | BERPDU ::= [0] SEQUENCE | |
22858 | { | |
22859 | b BOOLEAN OPTIONAL, | |
22860 | c INTEGER OPTIONAL | |
22861 | } | |
22862 | ||
22863 | ||
22864 | END | |
22865 | ||
22866 | <STATIC> | |
22867 | ||
22868 | import from TempA all; | |
22869 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22870 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22871 | ||
22872 | const BERPDU myValue := {b := true, | |
22873 | c := 5 } | |
22874 | ||
22875 | <TTCN_TC:EXEC> | |
22876 | ||
22877 | ||
22878 | ||
22879 | ||
22880 | if ((enc_DER_PDU(myValue) == 'A0060101FF020105'O)and(enc_CER_PDU(myValue) == 'A0800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22881 | ||
22882 | <RESULT> | |
22883 | ||
22884 | Overall verdict: pass | |
22885 | ||
22886 | <END_TC> | |
22887 | ||
22888 | :exmp. | |
22889 | ||
22890 | .*---------------------------------------------------------------------* | |
22891 | :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT | |
22892 | .*---------------------------------------------------------------------* | |
22893 | :xmp tab=0. | |
22894 | ||
22895 | <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT> | |
22896 | ||
22897 | <STATIC:ASN> | |
22898 | ||
22899 | TempA | |
22900 | ||
22901 | DEFINITIONS | |
22902 | ||
22903 | EXPLICIT TAGS | |
22904 | ||
22905 | ::= | |
22906 | ||
22907 | BEGIN | |
22908 | ||
22909 | BERPDU ::= [0] SEQUENCE | |
22910 | { | |
22911 | b BOOLEAN OPTIONAL, | |
22912 | c INTEGER OPTIONAL | |
22913 | } | |
22914 | ||
22915 | ||
22916 | END | |
22917 | ||
22918 | <STATIC> | |
22919 | ||
22920 | import from TempA all; | |
22921 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22922 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22923 | ||
22924 | const BERPDU myValue := {b := true, | |
22925 | c := 5 } | |
22926 | ||
22927 | <TTCN_TC:EXEC> | |
22928 | ||
22929 | ||
22930 | ||
22931 | ||
22932 | if ((enc_DER_PDU(myValue) == 'A00830060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08030800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22933 | ||
22934 | <RESULT> | |
22935 | ||
22936 | Overall verdict: pass | |
22937 | ||
22938 | <END_TC> | |
22939 | ||
22940 | :exmp. | |
22941 | ||
22942 | .*---------------------------------------------------------------------* | |
22943 | :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used) | |
22944 | .*---------------------------------------------------------------------* | |
22945 | :xmp tab=0. | |
22946 | ||
22947 | <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used)> | |
22948 | ||
22949 | <STATIC:ASN> | |
22950 | ||
22951 | TempA | |
22952 | ||
22953 | DEFINITIONS ::= | |
22954 | BEGIN | |
22955 | ||
22956 | BERPDU ::= [0] SEQUENCE | |
22957 | { | |
22958 | b [0] BOOLEAN OPTIONAL, | |
22959 | c [1] INTEGER OPTIONAL | |
22960 | } | |
22961 | ||
22962 | ||
22963 | END | |
22964 | ||
22965 | <STATIC> | |
22966 | ||
22967 | import from TempA all; | |
22968 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
22969 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
22970 | ||
22971 | const BERPDU myValue := {b := true, | |
22972 | c := 5 } | |
22973 | ||
22974 | <TTCN_TC:EXEC> | |
22975 | ||
22976 | ||
22977 | ||
22978 | ||
22979 | if ((enc_DER_PDU(myValue) == 'A00C300AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803080A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
22980 | ||
22981 | <RESULT> | |
22982 | ||
22983 | Overall verdict: pass | |
22984 | ||
22985 | <END_TC> | |
22986 | ||
22987 | :exmp. | |
22988 | ||
22989 | .*---------------------------------------------------------------------* | |
22990 | :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT | |
22991 | .*---------------------------------------------------------------------* | |
22992 | :xmp tab=0. | |
22993 | ||
22994 | <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT> | |
22995 | ||
22996 | <STATIC:ASN> | |
22997 | ||
22998 | TempA | |
22999 | ||
23000 | DEFINITIONS | |
23001 | ||
23002 | EXPLICIT TAGS | |
23003 | ||
23004 | ::= | |
23005 | ||
23006 | BEGIN | |
23007 | ||
23008 | BERPDU ::= [0] SEQUENCE | |
23009 | { | |
23010 | b [0] BOOLEAN OPTIONAL, | |
23011 | c [1] INTEGER OPTIONAL | |
23012 | } | |
23013 | ||
23014 | ||
23015 | END | |
23016 | ||
23017 | <STATIC> | |
23018 | ||
23019 | import from TempA all; | |
23020 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
23021 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
23022 | ||
23023 | const BERPDU myValue := {b := true, | |
23024 | c := 5 } | |
23025 | ||
23026 | <TTCN_TC:EXEC> | |
23027 | ||
23028 | ||
23029 | ||
23030 | ||
23031 | if ((enc_DER_PDU(myValue) == 'A00C300AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803080A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
23032 | ||
23033 | <RESULT> | |
23034 | ||
23035 | Overall verdict: pass | |
23036 | ||
23037 | <END_TC> | |
23038 | ||
23039 | :exmp. | |
23040 | ||
23041 | .*---------------------------------------------------------------------* | |
23042 | :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT | |
23043 | .*---------------------------------------------------------------------* | |
23044 | :xmp tab=0. | |
23045 | ||
23046 | <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT> | |
23047 | ||
23048 | <STATIC:ASN> | |
23049 | ||
23050 | TempA | |
23051 | ||
23052 | DEFINITIONS | |
23053 | ||
23054 | IMPLICIT TAGS | |
23055 | ||
23056 | ::= | |
23057 | ||
23058 | BEGIN | |
23059 | ||
23060 | BERPDU ::= [0] SEQUENCE | |
23061 | { | |
23062 | b [0] BOOLEAN OPTIONAL, | |
23063 | c [1] INTEGER OPTIONAL | |
23064 | } | |
23065 | ||
23066 | ||
23067 | END | |
23068 | ||
23069 | <STATIC> | |
23070 | ||
23071 | import from TempA all; | |
23072 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
23073 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
23074 | ||
23075 | const BERPDU myValue := {b := true, | |
23076 | c := 5 } | |
23077 | ||
23078 | <TTCN_TC:EXEC> | |
23079 | ||
23080 | ||
23081 | ||
23082 | ||
23083 | if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
23084 | ||
23085 | <RESULT> | |
23086 | ||
23087 | Overall verdict: pass | |
23088 | ||
23089 | <END_TC> | |
23090 | ||
23091 | :exmp. | |
23092 | ||
23093 | .*---------------------------------------------------------------------* | |
23094 | :h3.CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT | |
23095 | .*---------------------------------------------------------------------* | |
23096 | :xmp tab=0. | |
23097 | ||
23098 | <TC - CER + DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT> | |
23099 | ||
23100 | <STATIC:ASN> | |
23101 | ||
23102 | TempA | |
23103 | ||
23104 | DEFINITIONS | |
23105 | ||
23106 | AUTOMATIC TAGS | |
23107 | ||
23108 | ::= | |
23109 | ||
23110 | BEGIN | |
23111 | ||
23112 | BERPDU ::= [0] SEQUENCE | |
23113 | { | |
23114 | b [0] BOOLEAN OPTIONAL, | |
23115 | c [1] INTEGER OPTIONAL | |
23116 | } | |
23117 | ||
23118 | ||
23119 | END | |
23120 | ||
23121 | <STATIC> | |
23122 | ||
23123 | import from TempA all; | |
23124 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
23125 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
23126 | ||
23127 | const BERPDU myValue := {b := true, | |
23128 | c := 5 } | |
23129 | ||
23130 | <TTCN_TC:EXEC> | |
23131 | ||
23132 | ||
23133 | ||
23134 | ||
23135 | if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
23136 | ||
23137 | <RESULT> | |
23138 | ||
23139 | Overall verdict: pass | |
23140 | ||
23141 | <END_TC> | |
23142 | ||
23143 | :exmp. | |
23144 | ||
23145 | .*---------------------------------------------------------------------* | |
23146 | :h3.CER + DER encoding of SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT | |
23147 | .*---------------------------------------------------------------------* | |
23148 | :xmp tab=0. | |
23149 | ||
23150 | <TC - CER + DER encoding of SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT> | |
23151 | ||
23152 | <STATIC:ASN> | |
23153 | ||
23154 | TempA | |
23155 | ||
23156 | DEFINITIONS | |
23157 | ||
23158 | AUTOMATIC TAGS | |
23159 | ||
23160 | ::= | |
23161 | ||
23162 | BEGIN | |
23163 | ||
23164 | BERPDU ::= SEQUENCE | |
23165 | { | |
23166 | b [5] BOOLEAN OPTIONAL, | |
23167 | c INTEGER OPTIONAL | |
23168 | } | |
23169 | ||
23170 | ||
23171 | END | |
23172 | ||
23173 | <STATIC> | |
23174 | ||
23175 | import from TempA all; | |
23176 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
23177 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
23178 | ||
23179 | const BERPDU myValue := {b := true, | |
23180 | c := 5 } | |
23181 | ||
23182 | <TTCN_TC:EXEC> | |
23183 | ||
23184 | ||
23185 | ||
23186 | ||
23187 | if ((enc_DER_PDU(myValue) == '30068501FF020105'O)and(enc_CER_PDU(myValue) == '30808501FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
23188 | ||
23189 | <RESULT> | |
23190 | ||
23191 | Overall verdict: pass | |
23192 | ||
23193 | <END_TC> | |
23194 | ||
23195 | :exmp. | |
23196 | ||
23197 | .*---------------------------------------------------------------------* | |
23198 | :h3.CER + DER encoding of SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags | |
23199 | .*---------------------------------------------------------------------* | |
23200 | :xmp tab=0. | |
23201 | ||
23202 | <TC - CER + DER encoding of SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags> | |
23203 | ||
23204 | <STATIC:ASN> | |
23205 | ||
23206 | TempA | |
23207 | ||
23208 | DEFINITIONS | |
23209 | ||
23210 | AUTOMATIC TAGS | |
23211 | ||
23212 | ||
23213 | ::= | |
23214 | ||
23215 | BEGIN | |
23216 | ||
23217 | MySeq ::= SEQUENCE | |
23218 | {x INTEGER OPTIONAL, | |
23219 | y OCTET STRING} | |
23220 | ||
23221 | ||
23222 | ||
23223 | BERPDU ::= SEQUENCE | |
23224 | { | |
23225 | b BOOLEAN OPTIONAL, | |
23226 | c INTEGER OPTIONAL, | |
23227 | COMPONENTS OF MySeq | |
23228 | } | |
23229 | ||
23230 | ||
23231 | END | |
23232 | ||
23233 | <STATIC> | |
23234 | ||
23235 | import from TempA all; | |
23236 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
23237 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
23238 | ||
23239 | const BERPDU myValue := {b := true, | |
23240 | c := 5 , | |
23241 | x := 6, | |
23242 | y := 'FF'O } | |
23243 | ||
23244 | <TTCN_TC:EXEC> | |
23245 | ||
23246 | ||
23247 | ||
23248 | ||
23249 | if ((enc_DER_PDU(myValue) == '300C8001FF8101058201068301FF'O)and(enc_CER_PDU(myValue) == '30808001FF8101058201068301FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
23250 | ||
23251 | <RESULT> | |
23252 | ||
23253 | Overall verdict: pass | |
23254 | ||
23255 | <END_TC> | |
23256 | ||
23257 | :exmp. | |
23258 | ||
23259 | .*---------------------------------------------------------------------* | |
23260 | :h3.CER + DER encoding of SEQUENCE , one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
23261 | .*---------------------------------------------------------------------* | |
23262 | :xmp tab=0. | |
23263 | ||
23264 | <TC - CER + DER encoding of SEQUENCE , one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
23265 | ||
23266 | <STATIC:ASN> | |
23267 | ||
23268 | TempA | |
23269 | ||
23270 | DEFINITIONS | |
23271 | ||
23272 | AUTOMATIC TAGS | |
23273 | ||
23274 | ::= | |
23275 | ||
23276 | BEGIN | |
23277 | ||
23278 | MySeq ::= SEQUENCE | |
23279 | {x [0] INTEGER OPTIONAL, | |
23280 | y OCTET STRING} | |
23281 | ||
23282 | ||
23283 | ||
23284 | BERPDU ::= SEQUENCE | |
23285 | { | |
23286 | b BOOLEAN OPTIONAL, | |
23287 | c INTEGER OPTIONAL, | |
23288 | COMPONENTS OF MySeq | |
23289 | } | |
23290 | ||
23291 | ||
23292 | END | |
23293 | ||
23294 | <STATIC> | |
23295 | ||
23296 | import from TempA all; | |
23297 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
23298 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
23299 | ||
23300 | const BERPDU myValue := {b := true, | |
23301 | c := 5 , | |
23302 | x := 6, | |
23303 | y := 'FF'O } | |
23304 | ||
23305 | <TTCN_TC:EXEC> | |
23306 | ||
23307 | ||
23308 | ||
23309 | ||
23310 | if ((enc_DER_PDU(myValue) == '300C8001FF8101058201068301FF'O)and(enc_CER_PDU(myValue) == '30808001FF8101058201068301FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
23311 | ||
23312 | <RESULT> | |
23313 | ||
23314 | Overall verdict: pass | |
23315 | ||
23316 | <END_TC> | |
23317 | ||
23318 | :exmp. | |
23319 | ||
23320 | .*---------------------------------------------------------------------* | |
23321 | :h3.CER + DER encoding of SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
23322 | .*---------------------------------------------------------------------* | |
23323 | :xmp tab=0. | |
23324 | ||
23325 | <TC - CER + DER encoding of SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
23326 | ||
23327 | <STATIC:ASN> | |
23328 | ||
23329 | TempA | |
23330 | ||
23331 | DEFINITIONS | |
23332 | ||
23333 | AUTOMATIC TAGS | |
23334 | ||
23335 | ::= | |
23336 | ||
23337 | BEGIN | |
23338 | ||
23339 | ||
23340 | MySeq ::= SEQUENCE | |
23341 | {x INTEGER OPTIONAL, | |
23342 | y OCTET STRING} | |
23343 | ||
23344 | ||
23345 | ||
23346 | BERPDU ::= SEQUENCE | |
23347 | { | |
23348 | b [0] BOOLEAN OPTIONAL, | |
23349 | c BIT STRING OPTIONAL, | |
23350 | COMPONENTS OF MySeq | |
23351 | } | |
23352 | ||
23353 | ||
23354 | END | |
23355 | ||
23356 | <STATIC> | |
23357 | ||
23358 | import from TempA all; | |
23359 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
23360 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
23361 | ||
23362 | const BERPDU myValue := {b := true, | |
23363 | c := '1'B , | |
23364 | x := 6, | |
23365 | y := 'FF'O } | |
23366 | ||
23367 | <TTCN_TC:EXEC> | |
23368 | ||
23369 | ||
23370 | ||
23371 | ||
23372 | if ((enc_DER_PDU(myValue) == '300D8001FF030207800201060401FF'O)and(enc_CER_PDU(myValue) == '30808001FF030207800201060401FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
23373 | ||
23374 | <RESULT> | |
23375 | ||
23376 | Overall verdict: pass | |
23377 | ||
23378 | <END_TC> | |
23379 | ||
23380 | :exmp. | |
23381 | ||
23382 | .*---------------------------------------------------------------------* | |
23383 | :h3.CER + DER encoding of SEQUENCE , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
23384 | .*---------------------------------------------------------------------* | |
23385 | :xmp tab=0. | |
23386 | ||
23387 | <TC - CER + DER encoding of SEQUENCE , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
23388 | ||
23389 | <STATIC:ASN> | |
23390 | ||
23391 | TempA | |
23392 | ||
23393 | DEFINITIONS | |
23394 | ||
23395 | AUTOMATIC TAGS | |
23396 | ||
23397 | ::= | |
23398 | ||
23399 | BEGIN | |
23400 | ||
23401 | MySeq ::= SEQUENCE | |
23402 | {x [1] INTEGER OPTIONAL, | |
23403 | y OCTET STRING} | |
23404 | ||
23405 | ||
23406 | ||
23407 | BERPDU ::= SEQUENCE | |
23408 | { | |
23409 | b [0] BOOLEAN OPTIONAL, | |
23410 | c BIT STRING OPTIONAL, | |
23411 | COMPONENTS OF MySeq | |
23412 | } | |
23413 | ||
23414 | ||
23415 | ||
23416 | END | |
23417 | ||
23418 | <STATIC> | |
23419 | ||
23420 | import from TempA all; | |
23421 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
23422 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
23423 | ||
23424 | const BERPDU myValue := {b := true, | |
23425 | c := '1'B , | |
23426 | x := 6, | |
23427 | y := 'FF'O } | |
23428 | ||
23429 | <TTCN_TC:EXEC> | |
23430 | ||
23431 | ||
23432 | ||
23433 | ||
23434 | if ((enc_DER_PDU(myValue) == '300D8001FF030207808101060401FF'O)and(enc_CER_PDU(myValue) == '30808001FF030207808101060401FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
23435 | ||
23436 | <RESULT> | |
23437 | ||
23438 | Overall verdict: pass | |
23439 | ||
23440 | <END_TC> | |
23441 | ||
23442 | :exmp. | |
23443 | ||
23444 | .*---------------------------------------------------------------------* | |
23445 | :h3.CER + DER encoding of SEQUENCE with CHOICE element, AUTOMATIC TAGS | |
23446 | .*---------------------------------------------------------------------* | |
23447 | :xmp tab=0. | |
23448 | ||
23449 | <TC - CER + DER encoding of SEQUENCE with CHOICE element, AUTOMATIC TAGS> | |
23450 | ||
23451 | <STATIC:ASN> | |
23452 | ||
23453 | TempA | |
23454 | ||
23455 | DEFINITIONS | |
23456 | ||
23457 | AUTOMATIC TAGS | |
23458 | ||
23459 | ::= | |
23460 | ||
23461 | BEGIN | |
23462 | ||
23463 | ||
23464 | ||
23465 | ||
23466 | BERPDU ::= SEQUENCE | |
23467 | { | |
23468 | b CHOICE { | |
23469 | x BOOLEAN, | |
23470 | y OCTET STRING | |
23471 | } | |
23472 | OPTIONAL, | |
23473 | ||
23474 | ||
23475 | c INTEGER OPTIONAL | |
23476 | ||
23477 | } | |
23478 | ||
23479 | ||
23480 | ||
23481 | END | |
23482 | ||
23483 | <STATIC> | |
23484 | ||
23485 | import from TempA all; | |
23486 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
23487 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
23488 | ||
23489 | const BERPDU myValue := {b := {x := true}, | |
23490 | c := 4 | |
23491 | } | |
23492 | <TTCN_TC:EXEC> | |
23493 | ||
23494 | ||
23495 | ||
23496 | ||
23497 | if ((enc_DER_PDU(myValue) == '3008A0038001FF810104'O)and(enc_CER_PDU(myValue) == '3080A0808001FF00008101040000'O)) {setverdict(pass);} else {setverdict(fail);} | |
23498 | ||
23499 | <RESULT> | |
23500 | ||
23501 | Overall verdict: pass | |
23502 | ||
23503 | <END_TC> | |
23504 | ||
23505 | :exmp. | |
23506 | ||
23507 | .*---------------------------------------------------------------------* | |
23508 | :h3.CER + DER encoding of SEQUENCE with CHOICE element, | |
23509 | .*---------------------------------------------------------------------* | |
23510 | :xmp tab=0. | |
23511 | ||
23512 | <TC - CER + DER encoding of SEQUENCE with CHOICE element, > | |
23513 | ||
23514 | <STATIC:ASN> | |
23515 | ||
23516 | TempA | |
23517 | ||
23518 | DEFINITIONS | |
23519 | ||
23520 | ||
23521 | ||
23522 | ::= | |
23523 | ||
23524 | BEGIN | |
23525 | ||
23526 | ||
23527 | ||
23528 | ||
23529 | BERPDU ::= SEQUENCE | |
23530 | { | |
23531 | b CHOICE { | |
23532 | x BOOLEAN, | |
23533 | y OCTET STRING | |
23534 | } | |
23535 | OPTIONAL, | |
23536 | ||
23537 | ||
23538 | c INTEGER OPTIONAL | |
23539 | ||
23540 | } | |
23541 | ||
23542 | ||
23543 | ||
23544 | END | |
23545 | ||
23546 | <STATIC> | |
23547 | ||
23548 | import from TempA all; | |
23549 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
23550 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
23551 | ||
23552 | const BERPDU myValue := {b := {x := true}, | |
23553 | c := 4 | |
23554 | } | |
23555 | <TTCN_TC:EXEC> | |
23556 | ||
23557 | ||
23558 | ||
23559 | ||
23560 | if ((enc_DER_PDU(myValue) == '30060101FF020104'O)and(enc_CER_PDU(myValue) == '30800101FF0201040000'O)) {setverdict(pass);} else {setverdict(fail);} | |
23561 | ||
23562 | <RESULT> | |
23563 | ||
23564 | Overall verdict: pass | |
23565 | ||
23566 | <END_TC> | |
23567 | ||
23568 | :exmp. | |
23569 | ||
23570 | .*---------------------------------------------------------------------* | |
23571 | :h3.CER + DER encoding of SEQUENCE with EXTENSION , AUTOMATIC TAGS | |
23572 | .*---------------------------------------------------------------------* | |
23573 | :xmp tab=0. | |
23574 | ||
23575 | <TC - CER + DER encoding of SEQUENCE with EXTENSION , AUTOMATIC TAGS> | |
23576 | ||
23577 | <STATIC:ASN> | |
23578 | ||
23579 | TempA | |
23580 | ||
23581 | DEFINITIONS | |
23582 | ||
23583 | AUTOMATIC TAGS | |
23584 | ||
23585 | ::= | |
23586 | ||
23587 | BEGIN | |
23588 | ||
23589 | ||
23590 | ||
23591 | ||
23592 | BERPDU ::= SEQUENCE | |
23593 | { | |
23594 | ||
23595 | a OCTET STRING, | |
23596 | ||
23597 | b BOOLEAN, | |
23598 | ||
23599 | ..., | |
23600 | ||
23601 | d BIT STRING, | |
23602 | ..., | |
23603 | ||
23604 | c INTEGER OPTIONAL | |
23605 | ||
23606 | } | |
23607 | ||
23608 | ||
23609 | ||
23610 | END | |
23611 | ||
23612 | <STATIC> | |
23613 | ||
23614 | import from TempA all; | |
23615 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
23616 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
23617 | ||
23618 | const BERPDU myValue := { | |
23619 | a := 'FF'O, | |
23620 | b := true, | |
23621 | d := '1'B, | |
23622 | c := 4 | |
23623 | } | |
23624 | <TTCN_TC:EXEC> | |
23625 | ||
23626 | ||
23627 | ||
23628 | ||
23629 | if ((enc_DER_PDU(myValue) == '300D8001FF8101FF83020780820104'O)and(enc_CER_PDU(myValue) == '30808001FF8101FF830207808201040000'O)) {setverdict(pass);} else {setverdict(fail);} | |
23630 | ||
23631 | <RESULT> | |
23632 | ||
23633 | Overall verdict: pass | |
23634 | ||
23635 | <END_TC> | |
23636 | ||
23637 | :exmp. | |
23638 | ||
23639 | .*---------------------------------------------------------------------* | |
23640 | :h3.CER + DER encoding of SEQUENCE with fields of different types | |
23641 | .*---------------------------------------------------------------------* | |
23642 | :xmp tab=0. | |
23643 | ||
23644 | <TC - CER + DER encoding of SEQUENCE with fields of different types> | |
23645 | ||
23646 | <STATIC:ASN> | |
23647 | ||
23648 | TempA | |
23649 | ||
23650 | DEFINITIONS ::= | |
23651 | BEGIN | |
23652 | ||
23653 | BERPDU ::= SEQUENCE | |
23654 | { | |
23655 | a NULL, | |
23656 | b BOOLEAN, | |
23657 | c INTEGER, | |
23658 | d ENUMERATED {first ,second ,third}, | |
23659 | e REAL, | |
23660 | f BIT STRING, | |
23661 | g OCTET STRING, | |
23662 | ||
23663 | h OBJECT IDENTIFIER, | |
23664 | i IA5String, | |
23665 | j CHOICE {x1 [1] BOOLEAN, | |
23666 | y1 [2] OCTET STRING}, | |
23667 | ||
23668 | k SEQUENCE{x2 NULL, | |
23669 | y2 BOOLEAN}, | |
23670 | ||
23671 | l SET { x3 BIT STRING, | |
23672 | y3 REAL}, | |
23673 | ||
23674 | m [3] SEQUENCE OF INTEGER, | |
23675 | n [4] SET OF BOOLEAN | |
23676 | } | |
23677 | ||
23678 | ||
23679 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
23680 | ||
23681 | ||
23682 | END | |
23683 | ||
23684 | <STATIC> | |
23685 | ||
23686 | import from TempA all; | |
23687 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
23688 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
23689 | ||
23690 | const BERPDU myValue := {a := NULL, | |
23691 | b := true, | |
23692 | c := 2, | |
23693 | d := first, | |
23694 | e := 1.0, | |
23695 | f := '1'B, | |
23696 | g := 'FFFF'O, | |
23697 | h := myOBJID, | |
23698 | i := "ABC", | |
23699 | j := {x1 := true } , | |
23700 | k := {x2 := NULL, | |
23701 | ||
23702 | y2 := true } , | |
23703 | l := {y3 := 1.0 , | |
23704 | ||
23705 | x3 := '1'B } , | |
23706 | m := | |
23707 | { 1 ,2 } , | |
23708 | n := | |
23709 | { true, true } | |
23710 | } | |
23711 | ||
23712 | ||
23713 | ||
23714 | ||
23715 | ||
23716 | ||
23717 | ||
23718 | ||
23719 | ||
23720 | ||
23721 | ||
23722 | <TTCN_TC:EXEC> | |
23723 | ||
23724 | ||
23725 | ||
23726 | ||
23727 | if ((enc_DER_PDU(myValue) == '305305000101FF0201020A0100090603312E452B30030207800402FFFF06030002031603414243A1030101FF300505000101FF310C03020780090603312E452B30A3083006020101020102A40831060101FF0101FF'O)and(enc_CER_PDU(myValue) == '308005000101FF0201020A0100090603312E452B30030207800402FFFF06030002031603414243A1800101FF0000308005000101FF0000318003020780090603312E452B300000A380308002010102010200000000A48031800101FF0101FF000000000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
23728 | ||
23729 | <RESULT> | |
23730 | ||
23731 | Overall verdict: pass | |
23732 | ||
23733 | <END_TC> | |
23734 | ||
23735 | :exmp. | |
23736 | ||
23737 | .*---------------------------------------------------------------------* | |
23738 | :h3.CER + DER encoding of SEQUENCE with fields of different types, AUTOMATIC TAGS | |
23739 | .*---------------------------------------------------------------------* | |
23740 | :xmp tab=0. | |
23741 | ||
23742 | <TC - CER + DER encoding of SEQUENCE with fields of different types, AUTOMATIC TAGS> | |
23743 | ||
23744 | <STATIC:ASN> | |
23745 | ||
23746 | TempA | |
23747 | ||
23748 | DEFINITIONS | |
23749 | ||
23750 | AUTOMATIC TAGS | |
23751 | ||
23752 | ::= | |
23753 | ||
23754 | BEGIN | |
23755 | ||
23756 | BERPDU ::= SEQUENCE | |
23757 | { | |
23758 | a NULL, | |
23759 | b BOOLEAN, | |
23760 | c INTEGER, | |
23761 | d ENUMERATED {first ,second ,third}, | |
23762 | e REAL, | |
23763 | f BIT STRING, | |
23764 | g OCTET STRING, | |
23765 | ||
23766 | h OBJECT IDENTIFIER, | |
23767 | i IA5String, | |
23768 | j CHOICE {x1 BOOLEAN, | |
23769 | y1 OCTET STRING}, | |
23770 | ||
23771 | k SEQUENCE{x2 NULL, | |
23772 | y2 BOOLEAN}, | |
23773 | ||
23774 | l SET { x3 BIT STRING, | |
23775 | y3 REAL}, | |
23776 | ||
23777 | m SEQUENCE OF INTEGER, | |
23778 | n SET OF BOOLEAN | |
23779 | } | |
23780 | ||
23781 | ||
23782 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
23783 | ||
23784 | ||
23785 | END | |
23786 | ||
23787 | <STATIC> | |
23788 | ||
23789 | import from TempA all; | |
23790 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
23791 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
23792 | ||
23793 | const BERPDU myValue := {a := NULL, | |
23794 | b := true, | |
23795 | c := 2, | |
23796 | d := first, | |
23797 | e := 1.0, | |
23798 | f := '1'B, | |
23799 | g := 'FFFF'O, | |
23800 | h := myOBJID, | |
23801 | i := "ABC", | |
23802 | j := {x1 := true } , | |
23803 | k := {x2 := NULL, | |
23804 | ||
23805 | y2 := true } , | |
23806 | l := {y3 := 1.0 , | |
23807 | ||
23808 | x3 := '1'B } , | |
23809 | m := | |
23810 | { 1 ,2 } , | |
23811 | n := | |
23812 | { true, true } | |
23813 | } | |
23814 | ||
23815 | ||
23816 | ||
23817 | ||
23818 | ||
23819 | ||
23820 | ||
23821 | ||
23822 | ||
23823 | ||
23824 | ||
23825 | <TTCN_TC:EXEC> | |
23826 | ||
23827 | ||
23828 | ||
23829 | ||
23830 | if ((enc_DER_PDU(myValue) == '304F80008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB0C80020780810603312E452B30AC06020101020102AD060101FF0101FF'O)and(enc_CER_PDU(myValue) == '308080008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB8080020780810603312E452B300000AC800201010201020000AD800101FF0101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
23831 | ||
23832 | <RESULT> | |
23833 | ||
23834 | Overall verdict: pass | |
23835 | ||
23836 | <END_TC> | |
23837 | ||
23838 | :exmp. | |
23839 | ||
23840 | .*---------------------------------------------------------------------* | |
23841 | :h3. DECODING DER , SEQUENCE (EMPTY) | |
23842 | .*---------------------------------------------------------------------* | |
23843 | :xmp tab=0. | |
23844 | ||
23845 | <TC - DECODING DER , SEQUENCE (EMPTY)> | |
23846 | ||
23847 | <STATIC:ASN> | |
23848 | ||
23849 | TempA | |
23850 | ||
23851 | DEFINITIONS ::= | |
23852 | BEGIN | |
23853 | BERPDU ::= SEQUENCE | |
23854 | { | |
23855 | b BOOLEAN OPTIONAL, | |
23856 | c INTEGER OPTIONAL | |
23857 | } | |
23858 | ||
23859 | END | |
23860 | ||
23861 | <STATIC> | |
23862 | ||
23863 | import from TempA all; | |
23864 | ||
23865 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
23866 | ||
23867 | ||
23868 | const BERPDU myValue := {b := omit, | |
23869 | c := omit } | |
23870 | ||
23871 | <TTCN_TC:EXEC> | |
23872 | ||
23873 | if (dec_BER_PDU('3000'O) == myValue) | |
23874 | ||
23875 | ||
23876 | ||
23877 | {setverdict(pass);} else {setverdict(fail);} | |
23878 | ||
23879 | ||
23880 | <RESULT> | |
23881 | ||
23882 | Overall verdict: pass | |
23883 | ||
23884 | <END_TC> | |
23885 | ||
23886 | :exmp. | |
23887 | ||
23888 | .*---------------------------------------------------------------------* | |
23889 | :h3. DECODING CER , SEQUENCE (EMPTY) | |
23890 | .*---------------------------------------------------------------------* | |
23891 | :xmp tab=0. | |
23892 | ||
23893 | <TC - DECODING CER , SEQUENCE (EMPTY)> | |
23894 | ||
23895 | <STATIC:ASN> | |
23896 | ||
23897 | TempA | |
23898 | ||
23899 | DEFINITIONS ::= | |
23900 | BEGIN | |
23901 | BERPDU ::= SEQUENCE | |
23902 | { | |
23903 | b BOOLEAN OPTIONAL, | |
23904 | c INTEGER OPTIONAL | |
23905 | } | |
23906 | ||
23907 | END | |
23908 | ||
23909 | <STATIC> | |
23910 | ||
23911 | import from TempA all; | |
23912 | ||
23913 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
23914 | ||
23915 | ||
23916 | const BERPDU myValue := {b := omit, | |
23917 | c := omit } | |
23918 | ||
23919 | <TTCN_TC:EXEC> | |
23920 | ||
23921 | if (dec_BER_PDU('30800000'O) == myValue) | |
23922 | ||
23923 | ||
23924 | ||
23925 | {setverdict(pass);} else {setverdict(fail);} | |
23926 | ||
23927 | ||
23928 | <RESULT> | |
23929 | ||
23930 | Overall verdict: pass | |
23931 | ||
23932 | <END_TC> | |
23933 | ||
23934 | :exmp. | |
23935 | ||
23936 | .*---------------------------------------------------------------------* | |
23937 | :h3.DECODING DER , SEQUENCE (only one element is used) | |
23938 | .*---------------------------------------------------------------------* | |
23939 | :xmp tab=0. | |
23940 | ||
23941 | <TC - DECODING DER , SEQUENCE (only one element is used)> | |
23942 | ||
23943 | <STATIC:ASN> | |
23944 | ||
23945 | TempA | |
23946 | ||
23947 | DEFINITIONS ::= | |
23948 | BEGIN | |
23949 | BERPDU ::= SEQUENCE | |
23950 | { | |
23951 | b BOOLEAN OPTIONAL, | |
23952 | c INTEGER OPTIONAL | |
23953 | } | |
23954 | ||
23955 | ||
23956 | END | |
23957 | ||
23958 | <STATIC> | |
23959 | ||
23960 | import from TempA all; | |
23961 | ||
23962 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
23963 | ||
23964 | ||
23965 | const BERPDU myValue := {b := true, | |
23966 | c := omit } | |
23967 | ||
23968 | <TTCN_TC:EXEC> | |
23969 | ||
23970 | if (dec_BER_PDU('30030101FF'O) == myValue) | |
23971 | ||
23972 | ||
23973 | ||
23974 | {setverdict(pass);} else {setverdict(fail);} | |
23975 | ||
23976 | ||
23977 | <RESULT> | |
23978 | ||
23979 | Overall verdict: pass | |
23980 | ||
23981 | <END_TC> | |
23982 | ||
23983 | :exmp. | |
23984 | ||
23985 | .*---------------------------------------------------------------------* | |
23986 | :h3.DECODING CER , SEQUENCE (only one element is used) | |
23987 | .*---------------------------------------------------------------------* | |
23988 | :xmp tab=0. | |
23989 | ||
23990 | <TC - DECODING CER , SEQUENCE (only one element is used)> | |
23991 | ||
23992 | <STATIC:ASN> | |
23993 | ||
23994 | TempA | |
23995 | ||
23996 | DEFINITIONS ::= | |
23997 | BEGIN | |
23998 | BERPDU ::= SEQUENCE | |
23999 | { | |
24000 | b BOOLEAN OPTIONAL, | |
24001 | c INTEGER OPTIONAL | |
24002 | } | |
24003 | ||
24004 | ||
24005 | END | |
24006 | ||
24007 | <STATIC> | |
24008 | ||
24009 | import from TempA all; | |
24010 | ||
24011 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24012 | ||
24013 | ||
24014 | const BERPDU myValue := {b := true, | |
24015 | c := omit } | |
24016 | ||
24017 | <TTCN_TC:EXEC> | |
24018 | ||
24019 | if (dec_BER_PDU('30800101FF0000'O) == myValue) | |
24020 | ||
24021 | ||
24022 | ||
24023 | {setverdict(pass);} else {setverdict(fail);} | |
24024 | ||
24025 | ||
24026 | <RESULT> | |
24027 | ||
24028 | Overall verdict: pass | |
24029 | ||
24030 | <END_TC> | |
24031 | ||
24032 | :exmp. | |
24033 | ||
24034 | .*---------------------------------------------------------------------* | |
24035 | :h3. DECODING DER , SEQUENCE (both elements are used) | |
24036 | .*---------------------------------------------------------------------* | |
24037 | :xmp tab=0. | |
24038 | ||
24039 | <TC - DECODING DER , SEQUENCE (both elements are used)> | |
24040 | ||
24041 | <STATIC:ASN> | |
24042 | ||
24043 | TempA | |
24044 | ||
24045 | DEFINITIONS ::= | |
24046 | BEGIN | |
24047 | BERPDU ::= SEQUENCE | |
24048 | { | |
24049 | b BOOLEAN OPTIONAL, | |
24050 | c INTEGER OPTIONAL | |
24051 | } | |
24052 | ||
24053 | ||
24054 | END | |
24055 | ||
24056 | <STATIC> | |
24057 | ||
24058 | import from TempA all; | |
24059 | ||
24060 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24061 | ||
24062 | ||
24063 | const BERPDU myValue := {b := true, | |
24064 | c := 5 } | |
24065 | ||
24066 | ||
24067 | <TTCN_TC:EXEC> | |
24068 | ||
24069 | if (dec_BER_PDU('30060101FF020105'O) == myValue) | |
24070 | ||
24071 | ||
24072 | ||
24073 | {setverdict(pass);} else {setverdict(fail);} | |
24074 | ||
24075 | ||
24076 | <RESULT> | |
24077 | ||
24078 | Overall verdict: pass | |
24079 | ||
24080 | <END_TC> | |
24081 | ||
24082 | :exmp. | |
24083 | ||
24084 | .*---------------------------------------------------------------------* | |
24085 | :h3. DECODING DER , SEQUENCE (both elements are used) | |
24086 | .*---------------------------------------------------------------------* | |
24087 | :xmp tab=0. | |
24088 | ||
24089 | <TC - DECODING DER , SEQUENCE (both elements are used)> | |
24090 | ||
24091 | <STATIC:ASN> | |
24092 | ||
24093 | TempA | |
24094 | ||
24095 | DEFINITIONS ::= | |
24096 | BEGIN | |
24097 | BERPDU ::= SEQUENCE | |
24098 | { | |
24099 | b BOOLEAN OPTIONAL, | |
24100 | c INTEGER OPTIONAL | |
24101 | } | |
24102 | ||
24103 | ||
24104 | END | |
24105 | ||
24106 | <STATIC> | |
24107 | ||
24108 | import from TempA all; | |
24109 | ||
24110 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24111 | ||
24112 | ||
24113 | const BERPDU myValue := {b := true, | |
24114 | c := 5 } | |
24115 | ||
24116 | ||
24117 | <TTCN_TC:EXEC> | |
24118 | ||
24119 | if (dec_BER_PDU('30800101FF0201050000'O) == myValue) | |
24120 | ||
24121 | ||
24122 | ||
24123 | {setverdict(pass);} else {setverdict(fail);} | |
24124 | ||
24125 | ||
24126 | <RESULT> | |
24127 | ||
24128 | Overall verdict: pass | |
24129 | ||
24130 | <END_TC> | |
24131 | ||
24132 | :exmp. | |
24133 | ||
24134 | .*---------------------------------------------------------------------* | |
24135 | :h3. DECODING DER , SEQUENCE (one element is equal to Default) | |
24136 | .*---------------------------------------------------------------------* | |
24137 | :xmp tab=0. | |
24138 | ||
24139 | <TC - DECODING DER , SEQUENCE (one element is equal to Default)> | |
24140 | ||
24141 | <STATIC:ASN> | |
24142 | ||
24143 | TempA | |
24144 | ||
24145 | DEFINITIONS ::= | |
24146 | BEGIN | |
24147 | BERPDU ::= SEQUENCE | |
24148 | { | |
24149 | b BOOLEAN DEFAULT TRUE, | |
24150 | c INTEGER OPTIONAL | |
24151 | } | |
24152 | ||
24153 | END | |
24154 | ||
24155 | <STATIC> | |
24156 | ||
24157 | import from TempA all; | |
24158 | ||
24159 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24160 | ||
24161 | ||
24162 | const BERPDU myValue := {b := true, | |
24163 | c := 5 } | |
24164 | <TTCN_TC:EXEC> | |
24165 | ||
24166 | if (dec_BER_PDU('3003020105'O) == myValue) | |
24167 | ||
24168 | ||
24169 | ||
24170 | {setverdict(pass);} else {setverdict(fail);} | |
24171 | ||
24172 | ||
24173 | <RESULT> | |
24174 | ||
24175 | Overall verdict: pass | |
24176 | ||
24177 | <END_TC> | |
24178 | ||
24179 | :exmp. | |
24180 | ||
24181 | .*---------------------------------------------------------------------* | |
24182 | :h3. DECODING CER, SEQUENCE (one element is equal to Default) | |
24183 | .*---------------------------------------------------------------------* | |
24184 | :xmp tab=0. | |
24185 | ||
24186 | <TC - DECODING CER, SEQUENCE (one element is equal to Default)> | |
24187 | ||
24188 | <STATIC:ASN> | |
24189 | ||
24190 | TempA | |
24191 | ||
24192 | DEFINITIONS ::= | |
24193 | BEGIN | |
24194 | BERPDU ::= SEQUENCE | |
24195 | { | |
24196 | b BOOLEAN DEFAULT TRUE, | |
24197 | c INTEGER OPTIONAL | |
24198 | } | |
24199 | ||
24200 | END | |
24201 | ||
24202 | <STATIC> | |
24203 | ||
24204 | import from TempA all; | |
24205 | ||
24206 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24207 | ||
24208 | ||
24209 | const BERPDU myValue := {b := true, | |
24210 | c := 5 } | |
24211 | <TTCN_TC:EXEC> | |
24212 | ||
24213 | if (dec_BER_PDU('30800201050000'O) == myValue) | |
24214 | ||
24215 | ||
24216 | ||
24217 | {setverdict(pass);} else {setverdict(fail);} | |
24218 | ||
24219 | ||
24220 | <RESULT> | |
24221 | ||
24222 | Overall verdict: pass | |
24223 | ||
24224 | <END_TC> | |
24225 | ||
24226 | :exmp. | |
24227 | ||
24228 | .*---------------------------------------------------------------------* | |
24229 | :h3. DECODING DER , SEQUENCE (one element is not equal to Default) | |
24230 | .*---------------------------------------------------------------------* | |
24231 | :xmp tab=0. | |
24232 | ||
24233 | <TC - DECODING DER , SEQUENCE (one element is not equal to Default)> | |
24234 | ||
24235 | <STATIC:ASN> | |
24236 | ||
24237 | TempA | |
24238 | ||
24239 | DEFINITIONS ::= | |
24240 | BEGIN | |
24241 | ||
24242 | BERPDU ::= SEQUENCE | |
24243 | { | |
24244 | b BOOLEAN DEFAULT TRUE, | |
24245 | c INTEGER OPTIONAL | |
24246 | } | |
24247 | ||
24248 | ||
24249 | END | |
24250 | ||
24251 | <STATIC> | |
24252 | ||
24253 | import from TempA all; | |
24254 | ||
24255 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24256 | ||
24257 | ||
24258 | const BERPDU myValue := {b := false, | |
24259 | c := 5 } | |
24260 | <TTCN_TC:EXEC> | |
24261 | ||
24262 | if (dec_BER_PDU('3006010100020105'O) == myValue) | |
24263 | ||
24264 | ||
24265 | ||
24266 | {setverdict(pass);} else {setverdict(fail);} | |
24267 | ||
24268 | ||
24269 | <RESULT> | |
24270 | ||
24271 | Overall verdict: pass | |
24272 | ||
24273 | <END_TC> | |
24274 | ||
24275 | :exmp. | |
24276 | ||
24277 | .*---------------------------------------------------------------------* | |
24278 | :h3. DECODING CER , SEQUENCE (one element is not equal to Default) | |
24279 | .*---------------------------------------------------------------------* | |
24280 | :xmp tab=0. | |
24281 | ||
24282 | <TC - DECODING CER , SEQUENCE (one element is not equal to Default)> | |
24283 | ||
24284 | <STATIC:ASN> | |
24285 | ||
24286 | TempA | |
24287 | ||
24288 | DEFINITIONS ::= | |
24289 | BEGIN | |
24290 | ||
24291 | BERPDU ::= SEQUENCE | |
24292 | { | |
24293 | b BOOLEAN DEFAULT TRUE, | |
24294 | c INTEGER OPTIONAL | |
24295 | } | |
24296 | ||
24297 | ||
24298 | END | |
24299 | ||
24300 | <STATIC> | |
24301 | ||
24302 | import from TempA all; | |
24303 | ||
24304 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24305 | ||
24306 | ||
24307 | const BERPDU myValue := {b := false, | |
24308 | c := 5 } | |
24309 | <TTCN_TC:EXEC> | |
24310 | ||
24311 | if (dec_BER_PDU('30800101000201050000'O) == myValue) | |
24312 | ||
24313 | ||
24314 | ||
24315 | {setverdict(pass);} else {setverdict(fail);} | |
24316 | ||
24317 | ||
24318 | <RESULT> | |
24319 | ||
24320 | Overall verdict: pass | |
24321 | ||
24322 | <END_TC> | |
24323 | ||
24324 | :exmp. | |
24325 | ||
24326 | .*---------------------------------------------------------------------* | |
24327 | :h3. DECODING DER , SEQUENCE (EMPTY), AUTOMATIC TAGGING | |
24328 | .*---------------------------------------------------------------------* | |
24329 | :xmp tab=0. | |
24330 | ||
24331 | <TC - DECODING DER , SEQUENCE (EMPTY), AUTOMATIC TAGGING> | |
24332 | ||
24333 | <STATIC:ASN> | |
24334 | ||
24335 | TempA | |
24336 | ||
24337 | DEFINITIONS | |
24338 | ||
24339 | AUTOMATIC TAGS | |
24340 | ||
24341 | ||
24342 | ::= | |
24343 | ||
24344 | BEGIN | |
24345 | ||
24346 | BERPDU ::= SEQUENCE | |
24347 | { | |
24348 | b BOOLEAN OPTIONAL, | |
24349 | c INTEGER OPTIONAL | |
24350 | } | |
24351 | ||
24352 | ||
24353 | END | |
24354 | ||
24355 | <STATIC> | |
24356 | ||
24357 | import from TempA all; | |
24358 | ||
24359 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24360 | ||
24361 | ||
24362 | const BERPDU myValue := {b := omit, | |
24363 | c := omit } | |
24364 | ||
24365 | <TTCN_TC:EXEC> | |
24366 | ||
24367 | if (dec_BER_PDU('3000'O) == myValue) | |
24368 | ||
24369 | ||
24370 | ||
24371 | {setverdict(pass);} else {setverdict(fail);} | |
24372 | ||
24373 | ||
24374 | <RESULT> | |
24375 | ||
24376 | Overall verdict: pass | |
24377 | ||
24378 | <END_TC> | |
24379 | ||
24380 | :exmp. | |
24381 | ||
24382 | .*---------------------------------------------------------------------* | |
24383 | :h3. DECODING CER , SEQUENCE (EMPTY), AUTOMATIC TAGGING | |
24384 | .*---------------------------------------------------------------------* | |
24385 | :xmp tab=0. | |
24386 | ||
24387 | <TC - DECODING CER , SEQUENCE (EMPTY), AUTOMATIC TAGGING> | |
24388 | ||
24389 | <STATIC:ASN> | |
24390 | ||
24391 | TempA | |
24392 | ||
24393 | DEFINITIONS | |
24394 | ||
24395 | AUTOMATIC TAGS | |
24396 | ||
24397 | ||
24398 | ::= | |
24399 | ||
24400 | BEGIN | |
24401 | ||
24402 | BERPDU ::= SEQUENCE | |
24403 | { | |
24404 | b BOOLEAN OPTIONAL, | |
24405 | c INTEGER OPTIONAL | |
24406 | } | |
24407 | ||
24408 | ||
24409 | END | |
24410 | ||
24411 | <STATIC> | |
24412 | ||
24413 | import from TempA all; | |
24414 | ||
24415 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24416 | ||
24417 | ||
24418 | const BERPDU myValue := {b := omit, | |
24419 | c := omit } | |
24420 | ||
24421 | <TTCN_TC:EXEC> | |
24422 | ||
24423 | if (dec_BER_PDU('30800000'O) == myValue) | |
24424 | ||
24425 | ||
24426 | ||
24427 | {setverdict(pass);} else {setverdict(fail);} | |
24428 | ||
24429 | ||
24430 | <RESULT> | |
24431 | ||
24432 | Overall verdict: pass | |
24433 | ||
24434 | <END_TC> | |
24435 | ||
24436 | :exmp. | |
24437 | ||
24438 | .*---------------------------------------------------------------------* | |
24439 | :h3. DECODING DER , SEQUENCE (only one element is used) AUTOMATIC TAGGING | |
24440 | .*---------------------------------------------------------------------* | |
24441 | :xmp tab=0. | |
24442 | ||
24443 | <TC - DECODING DER , SEQUENCE (only one element is used) AUTOMATIC TAGGING> | |
24444 | ||
24445 | <STATIC:ASN> | |
24446 | ||
24447 | TempA | |
24448 | ||
24449 | DEFINITIONS | |
24450 | ||
24451 | AUTOMATIC TAGS | |
24452 | ||
24453 | ||
24454 | ::= | |
24455 | ||
24456 | BEGIN | |
24457 | ||
24458 | ||
24459 | BERPDU ::= SEQUENCE | |
24460 | { | |
24461 | b BOOLEAN OPTIONAL, | |
24462 | c INTEGER OPTIONAL | |
24463 | } | |
24464 | ||
24465 | ||
24466 | END | |
24467 | ||
24468 | <STATIC> | |
24469 | ||
24470 | import from TempA all; | |
24471 | ||
24472 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24473 | ||
24474 | ||
24475 | const BERPDU myValue := {b := true, | |
24476 | c := omit } | |
24477 | ||
24478 | <TTCN_TC:EXEC> | |
24479 | ||
24480 | if (dec_BER_PDU('30038001FF'O) == myValue) | |
24481 | ||
24482 | ||
24483 | ||
24484 | {setverdict(pass);} else {setverdict(fail);} | |
24485 | ||
24486 | ||
24487 | <RESULT> | |
24488 | ||
24489 | Overall verdict: pass | |
24490 | ||
24491 | <END_TC> | |
24492 | ||
24493 | :exmp. | |
24494 | ||
24495 | .*---------------------------------------------------------------------* | |
24496 | :h3. DECODING CER , SEQUENCE (only one element is used) AUTOMATIC TAGGING | |
24497 | .*---------------------------------------------------------------------* | |
24498 | :xmp tab=0. | |
24499 | ||
24500 | <TC - DECODING CER , SEQUENCE (only one element is used) AUTOMATIC TAGGING> | |
24501 | ||
24502 | <STATIC:ASN> | |
24503 | ||
24504 | TempA | |
24505 | ||
24506 | DEFINITIONS | |
24507 | ||
24508 | AUTOMATIC TAGS | |
24509 | ||
24510 | ||
24511 | ::= | |
24512 | ||
24513 | BEGIN | |
24514 | ||
24515 | ||
24516 | BERPDU ::= SEQUENCE | |
24517 | { | |
24518 | b BOOLEAN OPTIONAL, | |
24519 | c INTEGER OPTIONAL | |
24520 | } | |
24521 | ||
24522 | ||
24523 | END | |
24524 | ||
24525 | <STATIC> | |
24526 | ||
24527 | import from TempA all; | |
24528 | ||
24529 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24530 | ||
24531 | ||
24532 | const BERPDU myValue := {b := true, | |
24533 | c := omit } | |
24534 | ||
24535 | <TTCN_TC:EXEC> | |
24536 | ||
24537 | if (dec_BER_PDU('30808001FF0000'O) == myValue) | |
24538 | ||
24539 | ||
24540 | ||
24541 | {setverdict(pass);} else {setverdict(fail);} | |
24542 | ||
24543 | ||
24544 | <RESULT> | |
24545 | ||
24546 | Overall verdict: pass | |
24547 | ||
24548 | <END_TC> | |
24549 | ||
24550 | :exmp. | |
24551 | ||
24552 | .*---------------------------------------------------------------------* | |
24553 | :h3. DECODING DER , SEQUENCE (both elements are used) AUTOMATIC TAGGING | |
24554 | .*---------------------------------------------------------------------* | |
24555 | :xmp tab=0. | |
24556 | ||
24557 | <TC - DECODING DER , SEQUENCE (both elements are used) AUTOMATIC TAGGING> | |
24558 | ||
24559 | <STATIC:ASN> | |
24560 | ||
24561 | TempA | |
24562 | ||
24563 | DEFINITIONS | |
24564 | ||
24565 | AUTOMATIC TAGS | |
24566 | ||
24567 | ||
24568 | ::= | |
24569 | ||
24570 | BEGIN | |
24571 | ||
24572 | ||
24573 | BERPDU ::= SEQUENCE | |
24574 | { | |
24575 | b BOOLEAN OPTIONAL, | |
24576 | c INTEGER OPTIONAL | |
24577 | } | |
24578 | ||
24579 | ||
24580 | ||
24581 | END | |
24582 | ||
24583 | <STATIC> | |
24584 | ||
24585 | import from TempA all; | |
24586 | ||
24587 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24588 | ||
24589 | ||
24590 | const BERPDU myValue := {b := true, | |
24591 | c := 5 } | |
24592 | ||
24593 | <TTCN_TC:EXEC> | |
24594 | ||
24595 | if (dec_BER_PDU('30068001FF810105'O) == myValue) | |
24596 | ||
24597 | ||
24598 | ||
24599 | {setverdict(pass);} else {setverdict(fail);} | |
24600 | ||
24601 | ||
24602 | <RESULT> | |
24603 | ||
24604 | Overall verdict: pass | |
24605 | ||
24606 | <END_TC> | |
24607 | ||
24608 | :exmp. | |
24609 | ||
24610 | .*---------------------------------------------------------------------* | |
24611 | :h3. DECODING CER , SEQUENCE (both elements are used) AUTOMATIC TAGGING | |
24612 | .*---------------------------------------------------------------------* | |
24613 | :xmp tab=0. | |
24614 | ||
24615 | <TC - DECODING CER , SEQUENCE (both elements are used) AUTOMATIC TAGGING> | |
24616 | ||
24617 | <STATIC:ASN> | |
24618 | ||
24619 | TempA | |
24620 | ||
24621 | DEFINITIONS | |
24622 | ||
24623 | AUTOMATIC TAGS | |
24624 | ||
24625 | ||
24626 | ::= | |
24627 | ||
24628 | BEGIN | |
24629 | ||
24630 | ||
24631 | BERPDU ::= SEQUENCE | |
24632 | { | |
24633 | b BOOLEAN OPTIONAL, | |
24634 | c INTEGER OPTIONAL | |
24635 | } | |
24636 | ||
24637 | ||
24638 | ||
24639 | END | |
24640 | ||
24641 | <STATIC> | |
24642 | ||
24643 | import from TempA all; | |
24644 | ||
24645 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24646 | ||
24647 | ||
24648 | const BERPDU myValue := {b := true, | |
24649 | c := 5 } | |
24650 | ||
24651 | <TTCN_TC:EXEC> | |
24652 | ||
24653 | if (dec_BER_PDU('30808001FF8101050000'O) == myValue) | |
24654 | ||
24655 | ||
24656 | ||
24657 | {setverdict(pass);} else {setverdict(fail);} | |
24658 | ||
24659 | ||
24660 | <RESULT> | |
24661 | ||
24662 | Overall verdict: pass | |
24663 | ||
24664 | <END_TC> | |
24665 | ||
24666 | :exmp. | |
24667 | ||
24668 | .*---------------------------------------------------------------------* | |
24669 | :h3. DECODING DER , SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING | |
24670 | .*---------------------------------------------------------------------* | |
24671 | :xmp tab=0. | |
24672 | ||
24673 | <TC - DECODING DER , SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING > | |
24674 | ||
24675 | <STATIC:ASN> | |
24676 | ||
24677 | TempA | |
24678 | ||
24679 | DEFINITIONS | |
24680 | ||
24681 | AUTOMATIC TAGS | |
24682 | ||
24683 | ||
24684 | ::= | |
24685 | ||
24686 | BEGIN | |
24687 | ||
24688 | ||
24689 | BERPDU ::= SEQUENCE | |
24690 | { | |
24691 | b BOOLEAN DEFAULT TRUE, | |
24692 | c INTEGER OPTIONAL | |
24693 | } | |
24694 | ||
24695 | ||
24696 | ||
24697 | END | |
24698 | ||
24699 | <STATIC> | |
24700 | ||
24701 | import from TempA all; | |
24702 | ||
24703 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24704 | ||
24705 | ||
24706 | const BERPDU myValue := {b := true, | |
24707 | c := 5 } | |
24708 | ||
24709 | <TTCN_TC:EXEC> | |
24710 | ||
24711 | if (dec_BER_PDU('3003810105'O) == myValue) | |
24712 | ||
24713 | ||
24714 | ||
24715 | {setverdict(pass);} else {setverdict(fail);} | |
24716 | ||
24717 | ||
24718 | <RESULT> | |
24719 | ||
24720 | Overall verdict: pass | |
24721 | ||
24722 | <END_TC> | |
24723 | ||
24724 | :exmp. | |
24725 | ||
24726 | .*---------------------------------------------------------------------* | |
24727 | :h3. DECODING CER , SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING | |
24728 | .*---------------------------------------------------------------------* | |
24729 | :xmp tab=0. | |
24730 | ||
24731 | <TC - DECODING CER , SEQUENCE (one element is equal to Default) AUTOMATIC TAGGING > | |
24732 | ||
24733 | <STATIC:ASN> | |
24734 | ||
24735 | TempA | |
24736 | ||
24737 | DEFINITIONS | |
24738 | ||
24739 | AUTOMATIC TAGS | |
24740 | ||
24741 | ||
24742 | ::= | |
24743 | ||
24744 | BEGIN | |
24745 | ||
24746 | ||
24747 | BERPDU ::= SEQUENCE | |
24748 | { | |
24749 | b BOOLEAN DEFAULT TRUE, | |
24750 | c INTEGER OPTIONAL | |
24751 | } | |
24752 | ||
24753 | ||
24754 | ||
24755 | END | |
24756 | ||
24757 | <STATIC> | |
24758 | ||
24759 | import from TempA all; | |
24760 | ||
24761 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24762 | ||
24763 | ||
24764 | const BERPDU myValue := {b := true, | |
24765 | c := 5 } | |
24766 | ||
24767 | <TTCN_TC:EXEC> | |
24768 | ||
24769 | if (dec_BER_PDU('30808101050000'O) == myValue) | |
24770 | ||
24771 | ||
24772 | ||
24773 | {setverdict(pass);} else {setverdict(fail);} | |
24774 | ||
24775 | ||
24776 | <RESULT> | |
24777 | ||
24778 | Overall verdict: pass | |
24779 | ||
24780 | <END_TC> | |
24781 | ||
24782 | :exmp. | |
24783 | ||
24784 | .*---------------------------------------------------------------------* | |
24785 | :h3. DECODING DER ,SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING | |
24786 | .*---------------------------------------------------------------------* | |
24787 | :xmp tab=0. | |
24788 | ||
24789 | <TC - DECODING DER ,SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING> | |
24790 | ||
24791 | <STATIC:ASN> | |
24792 | ||
24793 | TempA | |
24794 | ||
24795 | DEFINITIONS | |
24796 | ||
24797 | AUTOMATIC TAGS | |
24798 | ||
24799 | ||
24800 | ::= | |
24801 | ||
24802 | BEGIN | |
24803 | ||
24804 | ||
24805 | BERPDU ::= SEQUENCE | |
24806 | { | |
24807 | b BOOLEAN DEFAULT TRUE, | |
24808 | c INTEGER OPTIONAL | |
24809 | } | |
24810 | ||
24811 | ||
24812 | ||
24813 | END | |
24814 | ||
24815 | <STATIC> | |
24816 | ||
24817 | import from TempA all; | |
24818 | ||
24819 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24820 | ||
24821 | ||
24822 | const BERPDU myValue := {b := false, | |
24823 | c := 5 } | |
24824 | ||
24825 | <TTCN_TC:EXEC> | |
24826 | ||
24827 | if (dec_BER_PDU('3006800100810105'O) == myValue) | |
24828 | ||
24829 | ||
24830 | ||
24831 | {setverdict(pass);} else {setverdict(fail);} | |
24832 | ||
24833 | ||
24834 | <RESULT> | |
24835 | ||
24836 | Overall verdict: pass | |
24837 | ||
24838 | <END_TC> | |
24839 | ||
24840 | :exmp. | |
24841 | ||
24842 | .*---------------------------------------------------------------------* | |
24843 | :h3. DECODING CER ,SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING | |
24844 | .*---------------------------------------------------------------------* | |
24845 | :xmp tab=0. | |
24846 | ||
24847 | <TC - DECODING CER ,SEQUENCE (one element is not equal to Default) AUTOMATIC TAGGING> | |
24848 | ||
24849 | <STATIC:ASN> | |
24850 | ||
24851 | TempA | |
24852 | ||
24853 | DEFINITIONS | |
24854 | ||
24855 | AUTOMATIC TAGS | |
24856 | ||
24857 | ||
24858 | ::= | |
24859 | ||
24860 | BEGIN | |
24861 | ||
24862 | ||
24863 | BERPDU ::= SEQUENCE | |
24864 | { | |
24865 | b BOOLEAN DEFAULT TRUE, | |
24866 | c INTEGER OPTIONAL | |
24867 | } | |
24868 | ||
24869 | ||
24870 | ||
24871 | END | |
24872 | ||
24873 | <STATIC> | |
24874 | ||
24875 | import from TempA all; | |
24876 | ||
24877 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24878 | ||
24879 | ||
24880 | const BERPDU myValue := {b := false, | |
24881 | c := 5 } | |
24882 | ||
24883 | <TTCN_TC:EXEC> | |
24884 | ||
24885 | if (dec_BER_PDU('30808001008101050000'O) == myValue) | |
24886 | ||
24887 | ||
24888 | ||
24889 | {setverdict(pass);} else {setverdict(fail);} | |
24890 | ||
24891 | ||
24892 | <RESULT> | |
24893 | ||
24894 | Overall verdict: pass | |
24895 | ||
24896 | <END_TC> | |
24897 | ||
24898 | :exmp. | |
24899 | ||
24900 | .*---------------------------------------------------------------------* | |
24901 | :h3. DECODING DER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements | |
24902 | .*---------------------------------------------------------------------* | |
24903 | :xmp tab=0. | |
24904 | ||
24905 | <TC - DECODING DER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements> | |
24906 | ||
24907 | <STATIC:ASN> | |
24908 | ||
24909 | TempA | |
24910 | ||
24911 | DEFINITIONS | |
24912 | ||
24913 | ||
24914 | ||
24915 | ||
24916 | ::= | |
24917 | ||
24918 | BEGIN | |
24919 | ||
24920 | ||
24921 | BERPDU ::= SEQUENCE | |
24922 | { | |
24923 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
24924 | c [31] IMPLICIT INTEGER OPTIONAL | |
24925 | } | |
24926 | ||
24927 | ||
24928 | END | |
24929 | ||
24930 | <STATIC> | |
24931 | ||
24932 | import from TempA all; | |
24933 | ||
24934 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24935 | ||
24936 | ||
24937 | const BERPDU myValue := {b := true, | |
24938 | c := 5 } | |
24939 | ||
24940 | <TTCN_TC:EXEC> | |
24941 | ||
24942 | if (dec_BER_PDU('30079E01FF9F1F0105'O) == myValue) | |
24943 | ||
24944 | ||
24945 | ||
24946 | {setverdict(pass);} else {setverdict(fail);} | |
24947 | ||
24948 | ||
24949 | <RESULT> | |
24950 | ||
24951 | Overall verdict: pass | |
24952 | ||
24953 | <END_TC> | |
24954 | ||
24955 | :exmp. | |
24956 | ||
24957 | .*---------------------------------------------------------------------* | |
24958 | :h3. DECODING CER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements | |
24959 | .*---------------------------------------------------------------------* | |
24960 | :xmp tab=0. | |
24961 | ||
24962 | <TC - DECODING CER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements> | |
24963 | ||
24964 | <STATIC:ASN> | |
24965 | ||
24966 | TempA | |
24967 | ||
24968 | DEFINITIONS | |
24969 | ||
24970 | ||
24971 | ||
24972 | ||
24973 | ::= | |
24974 | ||
24975 | BEGIN | |
24976 | ||
24977 | ||
24978 | BERPDU ::= SEQUENCE | |
24979 | { | |
24980 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
24981 | c [31] IMPLICIT INTEGER OPTIONAL | |
24982 | } | |
24983 | ||
24984 | ||
24985 | END | |
24986 | ||
24987 | <STATIC> | |
24988 | ||
24989 | import from TempA all; | |
24990 | ||
24991 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
24992 | ||
24993 | ||
24994 | const BERPDU myValue := {b := true, | |
24995 | c := 5 } | |
24996 | ||
24997 | <TTCN_TC:EXEC> | |
24998 | ||
24999 | if (dec_BER_PDU('30809E01FF9F1F01050000'O) == myValue) | |
25000 | ||
25001 | ||
25002 | ||
25003 | {setverdict(pass);} else {setverdict(fail);} | |
25004 | ||
25005 | ||
25006 | <RESULT> | |
25007 | ||
25008 | Overall verdict: pass | |
25009 | ||
25010 | <END_TC> | |
25011 | ||
25012 | :exmp. | |
25013 | ||
25014 | .*---------------------------------------------------------------------* | |
25015 | :h3. DECODING DER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT | |
25016 | .*---------------------------------------------------------------------* | |
25017 | :xmp tab=0. | |
25018 | ||
25019 | <TC - DECODING DER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT> | |
25020 | ||
25021 | <STATIC:ASN> | |
25022 | ||
25023 | TempA | |
25024 | ||
25025 | DEFINITIONS | |
25026 | ||
25027 | EXPLICIT TAGS | |
25028 | ||
25029 | ||
25030 | ::= | |
25031 | ||
25032 | BEGIN | |
25033 | ||
25034 | ||
25035 | BERPDU ::= SEQUENCE | |
25036 | { | |
25037 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
25038 | c [31] IMPLICIT INTEGER OPTIONAL | |
25039 | } | |
25040 | ||
25041 | ||
25042 | ||
25043 | END | |
25044 | ||
25045 | <STATIC> | |
25046 | ||
25047 | import from TempA all; | |
25048 | ||
25049 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25050 | ||
25051 | ||
25052 | const BERPDU myValue := {b := true, | |
25053 | c := 5 } | |
25054 | ||
25055 | ||
25056 | <TTCN_TC:EXEC> | |
25057 | ||
25058 | if (dec_BER_PDU('30079E01FF9F1F0105'O) == myValue) | |
25059 | ||
25060 | ||
25061 | ||
25062 | {setverdict(pass);} else {setverdict(fail);} | |
25063 | ||
25064 | ||
25065 | <RESULT> | |
25066 | ||
25067 | Overall verdict: pass | |
25068 | ||
25069 | <END_TC> | |
25070 | ||
25071 | :exmp. | |
25072 | ||
25073 | .*---------------------------------------------------------------------* | |
25074 | :h3. DECODING CER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT | |
25075 | .*---------------------------------------------------------------------* | |
25076 | :xmp tab=0. | |
25077 | ||
25078 | <TC - DECODING CER , SEQUENCE (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT> | |
25079 | ||
25080 | <STATIC:ASN> | |
25081 | ||
25082 | TempA | |
25083 | ||
25084 | DEFINITIONS | |
25085 | ||
25086 | EXPLICIT TAGS | |
25087 | ||
25088 | ||
25089 | ::= | |
25090 | ||
25091 | BEGIN | |
25092 | ||
25093 | ||
25094 | BERPDU ::= SEQUENCE | |
25095 | { | |
25096 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
25097 | c [31] IMPLICIT INTEGER OPTIONAL | |
25098 | } | |
25099 | ||
25100 | ||
25101 | ||
25102 | END | |
25103 | ||
25104 | <STATIC> | |
25105 | ||
25106 | import from TempA all; | |
25107 | ||
25108 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25109 | ||
25110 | ||
25111 | const BERPDU myValue := {b := true, | |
25112 | c := 5 } | |
25113 | ||
25114 | ||
25115 | <TTCN_TC:EXEC> | |
25116 | ||
25117 | if (dec_BER_PDU('30809E01FF9F1F01050000'O) == myValue) | |
25118 | ||
25119 | ||
25120 | ||
25121 | {setverdict(pass);} else {setverdict(fail);} | |
25122 | ||
25123 | ||
25124 | <RESULT> | |
25125 | ||
25126 | Overall verdict: pass | |
25127 | ||
25128 | <END_TC> | |
25129 | ||
25130 | :exmp. | |
25131 | ||
25132 | .*---------------------------------------------------------------------* | |
25133 | :h3. DECODING DER, SEQUENCE (both elements are used) EXPLICIT TAGS for elements | |
25134 | .*---------------------------------------------------------------------* | |
25135 | :xmp tab=0. | |
25136 | ||
25137 | <TC - DECODING DER, SEQUENCE (both elements are used) EXPLICIT TAGS for elements> | |
25138 | ||
25139 | <STATIC:ASN> | |
25140 | ||
25141 | TempA | |
25142 | ||
25143 | DEFINITIONS | |
25144 | ||
25145 | ||
25146 | ||
25147 | ::= | |
25148 | ||
25149 | BEGIN | |
25150 | ||
25151 | ||
25152 | BERPDU ::= SEQUENCE | |
25153 | { | |
25154 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
25155 | c [31] EXPLICIT INTEGER OPTIONAL | |
25156 | } | |
25157 | ||
25158 | ||
25159 | ||
25160 | END | |
25161 | ||
25162 | <STATIC> | |
25163 | ||
25164 | import from TempA all; | |
25165 | ||
25166 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25167 | ||
25168 | ||
25169 | const BERPDU myValue := {b := true, | |
25170 | c := 5 } | |
25171 | ||
25172 | ||
25173 | <TTCN_TC:EXEC> | |
25174 | ||
25175 | if (dec_BER_PDU('300BBE030101FFBF1F03020105'O) == myValue) | |
25176 | ||
25177 | ||
25178 | ||
25179 | {setverdict(pass);} else {setverdict(fail);} | |
25180 | ||
25181 | ||
25182 | <RESULT> | |
25183 | ||
25184 | Overall verdict: pass | |
25185 | ||
25186 | <END_TC> | |
25187 | ||
25188 | :exmp. | |
25189 | ||
25190 | .*---------------------------------------------------------------------* | |
25191 | :h3. DECODING CER, SEQUENCE (both elements are used) EXPLICIT TAGS for elements | |
25192 | .*---------------------------------------------------------------------* | |
25193 | :xmp tab=0. | |
25194 | ||
25195 | <TC - DECODING CER, SEQUENCE (both elements are used) EXPLICIT TAGS for elements> | |
25196 | ||
25197 | <STATIC:ASN> | |
25198 | ||
25199 | TempA | |
25200 | ||
25201 | DEFINITIONS | |
25202 | ||
25203 | ||
25204 | ||
25205 | ::= | |
25206 | ||
25207 | BEGIN | |
25208 | ||
25209 | ||
25210 | BERPDU ::= SEQUENCE | |
25211 | { | |
25212 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
25213 | c [31] EXPLICIT INTEGER OPTIONAL | |
25214 | } | |
25215 | ||
25216 | ||
25217 | ||
25218 | END | |
25219 | ||
25220 | <STATIC> | |
25221 | ||
25222 | import from TempA all; | |
25223 | ||
25224 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25225 | ||
25226 | ||
25227 | const BERPDU myValue := {b := true, | |
25228 | c := 5 } | |
25229 | ||
25230 | ||
25231 | <TTCN_TC:EXEC> | |
25232 | ||
25233 | if (dec_BER_PDU('3080BE800101FF0000BF1F8002010500000000'O) == myValue) | |
25234 | ||
25235 | ||
25236 | ||
25237 | {setverdict(pass);} else {setverdict(fail);} | |
25238 | ||
25239 | ||
25240 | <RESULT> | |
25241 | ||
25242 | Overall verdict: pass | |
25243 | ||
25244 | <END_TC> | |
25245 | ||
25246 | :exmp. | |
25247 | ||
25248 | .*---------------------------------------------------------------------* | |
25249 | :h3. DECODING DER , SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT | |
25250 | .*---------------------------------------------------------------------* | |
25251 | :xmp tab=0. | |
25252 | ||
25253 | <TC - DECODING DER , SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT> | |
25254 | ||
25255 | <STATIC:ASN> | |
25256 | ||
25257 | TempA | |
25258 | ||
25259 | DEFINITIONS | |
25260 | ||
25261 | IMPLICIT TAGS | |
25262 | ||
25263 | ||
25264 | ::= | |
25265 | ||
25266 | BEGIN | |
25267 | ||
25268 | ||
25269 | BERPDU ::= SEQUENCE | |
25270 | { | |
25271 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
25272 | c [31] EXPLICIT INTEGER OPTIONAL | |
25273 | } | |
25274 | ||
25275 | ||
25276 | END | |
25277 | ||
25278 | <STATIC> | |
25279 | ||
25280 | import from TempA all; | |
25281 | ||
25282 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25283 | ||
25284 | ||
25285 | const BERPDU myValue := {b := true, | |
25286 | c := 5 } | |
25287 | ||
25288 | ||
25289 | ||
25290 | <TTCN_TC:EXEC> | |
25291 | ||
25292 | if (dec_BER_PDU('300BBE030101FFBF1F03020105'O) == myValue) | |
25293 | ||
25294 | ||
25295 | ||
25296 | {setverdict(pass);} else {setverdict(fail);} | |
25297 | ||
25298 | ||
25299 | <RESULT> | |
25300 | ||
25301 | Overall verdict: pass | |
25302 | ||
25303 | <END_TC> | |
25304 | ||
25305 | :exmp. | |
25306 | ||
25307 | .*---------------------------------------------------------------------* | |
25308 | :h3. DECODING CER , SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT | |
25309 | .*---------------------------------------------------------------------* | |
25310 | :xmp tab=0. | |
25311 | ||
25312 | <TC - DECODING CER , SEQUENCE (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT> | |
25313 | ||
25314 | <STATIC:ASN> | |
25315 | ||
25316 | TempA | |
25317 | ||
25318 | DEFINITIONS | |
25319 | ||
25320 | IMPLICIT TAGS | |
25321 | ||
25322 | ||
25323 | ::= | |
25324 | ||
25325 | BEGIN | |
25326 | ||
25327 | ||
25328 | BERPDU ::= SEQUENCE | |
25329 | { | |
25330 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
25331 | c [31] EXPLICIT INTEGER OPTIONAL | |
25332 | } | |
25333 | ||
25334 | ||
25335 | END | |
25336 | ||
25337 | <STATIC> | |
25338 | ||
25339 | import from TempA all; | |
25340 | ||
25341 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25342 | ||
25343 | ||
25344 | const BERPDU myValue := {b := true, | |
25345 | c := 5 } | |
25346 | ||
25347 | ||
25348 | ||
25349 | <TTCN_TC:EXEC> | |
25350 | ||
25351 | if (dec_BER_PDU('3080BE800101FF0000BF1F8002010500000000'O) == myValue) | |
25352 | ||
25353 | ||
25354 | ||
25355 | {setverdict(pass);} else {setverdict(fail);} | |
25356 | ||
25357 | ||
25358 | <RESULT> | |
25359 | ||
25360 | Overall verdict: pass | |
25361 | ||
25362 | <END_TC> | |
25363 | ||
25364 | :exmp. | |
25365 | ||
25366 | .*---------------------------------------------------------------------* | |
25367 | :h3. DECODING , DER , TAGGED SEQUENCE (both elements are used) | |
25368 | .*---------------------------------------------------------------------* | |
25369 | :xmp tab=0. | |
25370 | ||
25371 | <TC - DECODING , DER , TAGGED SEQUENCE (both elements are used)> | |
25372 | ||
25373 | <STATIC:ASN> | |
25374 | ||
25375 | TempA | |
25376 | ||
25377 | DEFINITIONS | |
25378 | ||
25379 | ||
25380 | ||
25381 | ::= | |
25382 | ||
25383 | BEGIN | |
25384 | ||
25385 | ||
25386 | BERPDU ::= [0] SEQUENCE | |
25387 | { | |
25388 | b BOOLEAN OPTIONAL, | |
25389 | c INTEGER OPTIONAL | |
25390 | } | |
25391 | ||
25392 | ||
25393 | END | |
25394 | ||
25395 | <STATIC> | |
25396 | ||
25397 | import from TempA all; | |
25398 | ||
25399 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25400 | ||
25401 | ||
25402 | const BERPDU myValue := {b := true, | |
25403 | c := 5 } | |
25404 | ||
25405 | ||
25406 | ||
25407 | <TTCN_TC:EXEC> | |
25408 | ||
25409 | if (dec_BER_PDU('A00830060101FF020105'O) == myValue) | |
25410 | ||
25411 | ||
25412 | ||
25413 | {setverdict(pass);} else {setverdict(fail);} | |
25414 | ||
25415 | ||
25416 | <RESULT> | |
25417 | ||
25418 | Overall verdict: pass | |
25419 | ||
25420 | <END_TC> | |
25421 | ||
25422 | :exmp. | |
25423 | ||
25424 | .*---------------------------------------------------------------------* | |
25425 | :h3. DECODING , CER , TAGGED SEQUENCE (both elements are used) | |
25426 | .*---------------------------------------------------------------------* | |
25427 | :xmp tab=0. | |
25428 | ||
25429 | <TC - DECODING , CER , TAGGED SEQUENCE (both elements are used)> | |
25430 | ||
25431 | <STATIC:ASN> | |
25432 | ||
25433 | TempA | |
25434 | ||
25435 | DEFINITIONS | |
25436 | ||
25437 | ||
25438 | ||
25439 | ::= | |
25440 | ||
25441 | BEGIN | |
25442 | ||
25443 | ||
25444 | BERPDU ::= [0] SEQUENCE | |
25445 | { | |
25446 | b BOOLEAN OPTIONAL, | |
25447 | c INTEGER OPTIONAL | |
25448 | } | |
25449 | ||
25450 | ||
25451 | END | |
25452 | ||
25453 | <STATIC> | |
25454 | ||
25455 | import from TempA all; | |
25456 | ||
25457 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25458 | ||
25459 | ||
25460 | const BERPDU myValue := {b := true, | |
25461 | c := 5 } | |
25462 | ||
25463 | ||
25464 | ||
25465 | <TTCN_TC:EXEC> | |
25466 | ||
25467 | if (dec_BER_PDU('A08030800101FF02010500000000'O) == myValue) | |
25468 | ||
25469 | ||
25470 | ||
25471 | {setverdict(pass);} else {setverdict(fail);} | |
25472 | ||
25473 | ||
25474 | <RESULT> | |
25475 | ||
25476 | Overall verdict: pass | |
25477 | ||
25478 | <END_TC> | |
25479 | ||
25480 | :exmp. | |
25481 | ||
25482 | .*---------------------------------------------------------------------* | |
25483 | :h3. DECODING DER , TAGGED SEQUENCE (both elements are used) | |
25484 | .*---------------------------------------------------------------------* | |
25485 | :xmp tab=0. | |
25486 | ||
25487 | <TC - DECODING DER , TAGGED SEQUENCE (both elements are used)> | |
25488 | ||
25489 | <STATIC:ASN> | |
25490 | ||
25491 | TempA | |
25492 | ||
25493 | DEFINITIONS | |
25494 | ||
25495 | ||
25496 | ||
25497 | ::= | |
25498 | ||
25499 | BEGIN | |
25500 | ||
25501 | ||
25502 | BERPDU ::= [0] SEQUENCE | |
25503 | { | |
25504 | b BOOLEAN OPTIONAL, | |
25505 | c INTEGER OPTIONAL | |
25506 | } | |
25507 | ||
25508 | END | |
25509 | ||
25510 | <STATIC> | |
25511 | ||
25512 | import from TempA all; | |
25513 | ||
25514 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25515 | ||
25516 | ||
25517 | const BERPDU myValue := {b := true, | |
25518 | c := 5 } | |
25519 | ||
25520 | ||
25521 | ||
25522 | <TTCN_TC:EXEC> | |
25523 | ||
25524 | if (dec_BER_PDU('A00830060101FF020105'O) == myValue) | |
25525 | ||
25526 | ||
25527 | ||
25528 | {setverdict(pass);} else {setverdict(fail);} | |
25529 | ||
25530 | ||
25531 | <RESULT> | |
25532 | ||
25533 | Overall verdict: pass | |
25534 | ||
25535 | <END_TC> | |
25536 | ||
25537 | :exmp. | |
25538 | ||
25539 | .*---------------------------------------------------------------------* | |
25540 | :h3. DECODING CER , TAGGED SEQUENCE (both elements are used) | |
25541 | .*---------------------------------------------------------------------* | |
25542 | :xmp tab=0. | |
25543 | ||
25544 | <TC - DECODING CER , TAGGED SEQUENCE (both elements are used)> | |
25545 | ||
25546 | <STATIC:ASN> | |
25547 | ||
25548 | TempA | |
25549 | ||
25550 | DEFINITIONS | |
25551 | ||
25552 | ||
25553 | ||
25554 | ::= | |
25555 | ||
25556 | BEGIN | |
25557 | ||
25558 | ||
25559 | BERPDU ::= [0] SEQUENCE | |
25560 | { | |
25561 | b BOOLEAN OPTIONAL, | |
25562 | c INTEGER OPTIONAL | |
25563 | } | |
25564 | ||
25565 | END | |
25566 | ||
25567 | <STATIC> | |
25568 | ||
25569 | import from TempA all; | |
25570 | ||
25571 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25572 | ||
25573 | ||
25574 | const BERPDU myValue := {b := true, | |
25575 | c := 5 } | |
25576 | ||
25577 | ||
25578 | ||
25579 | <TTCN_TC:EXEC> | |
25580 | ||
25581 | if (dec_BER_PDU('A08030800101FF02010500000000'O) == myValue) | |
25582 | ||
25583 | ||
25584 | ||
25585 | {setverdict(pass);} else {setverdict(fail);} | |
25586 | ||
25587 | ||
25588 | <RESULT> | |
25589 | ||
25590 | Overall verdict: pass | |
25591 | ||
25592 | <END_TC> | |
25593 | ||
25594 | :exmp. | |
25595 | ||
25596 | .*---------------------------------------------------------------------* | |
25597 | :h3. DECODING DER , TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT | |
25598 | .*---------------------------------------------------------------------* | |
25599 | :xmp tab=0. | |
25600 | ||
25601 | <TC - DECODING DER , TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT> | |
25602 | ||
25603 | <STATIC:ASN> | |
25604 | ||
25605 | TempA | |
25606 | ||
25607 | DEFINITIONS | |
25608 | ||
25609 | IMPLICIT TAGS | |
25610 | ||
25611 | ||
25612 | ::= | |
25613 | ||
25614 | BEGIN | |
25615 | ||
25616 | ||
25617 | BERPDU ::= [0] SEQUENCE | |
25618 | { | |
25619 | b BOOLEAN OPTIONAL, | |
25620 | c INTEGER OPTIONAL | |
25621 | } | |
25622 | ||
25623 | ||
25624 | END | |
25625 | ||
25626 | <STATIC> | |
25627 | ||
25628 | import from TempA all; | |
25629 | ||
25630 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25631 | ||
25632 | ||
25633 | const BERPDU myValue := {b := true, | |
25634 | c := 5 } | |
25635 | ||
25636 | ||
25637 | <TTCN_TC:EXEC> | |
25638 | ||
25639 | if (dec_BER_PDU('A0060101FF020105'O) == myValue) | |
25640 | ||
25641 | ||
25642 | ||
25643 | {setverdict(pass);} else {setverdict(fail);} | |
25644 | ||
25645 | ||
25646 | <RESULT> | |
25647 | ||
25648 | Overall verdict: pass | |
25649 | ||
25650 | <END_TC> | |
25651 | ||
25652 | :exmp. | |
25653 | ||
25654 | .*---------------------------------------------------------------------* | |
25655 | :h3. DECODING CER , TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT | |
25656 | .*---------------------------------------------------------------------* | |
25657 | :xmp tab=0. | |
25658 | ||
25659 | <TC - DECODING CER , TAGGED SEQUENCE (both elements are used), IMPLICIT TAGGING ENVIRONMENT> | |
25660 | ||
25661 | <STATIC:ASN> | |
25662 | ||
25663 | TempA | |
25664 | ||
25665 | DEFINITIONS | |
25666 | ||
25667 | IMPLICIT TAGS | |
25668 | ||
25669 | ||
25670 | ::= | |
25671 | ||
25672 | BEGIN | |
25673 | ||
25674 | ||
25675 | BERPDU ::= [0] SEQUENCE | |
25676 | { | |
25677 | b BOOLEAN OPTIONAL, | |
25678 | c INTEGER OPTIONAL | |
25679 | } | |
25680 | ||
25681 | ||
25682 | END | |
25683 | ||
25684 | <STATIC> | |
25685 | ||
25686 | import from TempA all; | |
25687 | ||
25688 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25689 | ||
25690 | ||
25691 | const BERPDU myValue := {b := true, | |
25692 | c := 5 } | |
25693 | ||
25694 | ||
25695 | <TTCN_TC:EXEC> | |
25696 | ||
25697 | if (dec_BER_PDU('A0800101FF0201050000'O) == myValue) | |
25698 | ||
25699 | ||
25700 | ||
25701 | {setverdict(pass);} else {setverdict(fail);} | |
25702 | ||
25703 | ||
25704 | <RESULT> | |
25705 | ||
25706 | Overall verdict: pass | |
25707 | ||
25708 | <END_TC> | |
25709 | ||
25710 | :exmp. | |
25711 | ||
25712 | .*---------------------------------------------------------------------* | |
25713 | :h3. DECODING DER , TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT | |
25714 | .*---------------------------------------------------------------------* | |
25715 | :xmp tab=0. | |
25716 | ||
25717 | <TC - DECODING DER , TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT> | |
25718 | ||
25719 | <STATIC:ASN> | |
25720 | ||
25721 | TempA | |
25722 | ||
25723 | DEFINITIONS | |
25724 | ||
25725 | EXPLICIT TAGS | |
25726 | ||
25727 | ||
25728 | ::= | |
25729 | ||
25730 | BEGIN | |
25731 | ||
25732 | ||
25733 | BERPDU ::= [0] SEQUENCE | |
25734 | { | |
25735 | b BOOLEAN OPTIONAL, | |
25736 | c INTEGER OPTIONAL | |
25737 | } | |
25738 | ||
25739 | ||
25740 | END | |
25741 | ||
25742 | <STATIC> | |
25743 | ||
25744 | import from TempA all; | |
25745 | ||
25746 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25747 | ||
25748 | ||
25749 | const BERPDU myValue := {b := true, | |
25750 | c := 5 } | |
25751 | ||
25752 | ||
25753 | ||
25754 | <TTCN_TC:EXEC> | |
25755 | ||
25756 | if (dec_BER_PDU('A00830060101FF020105'O) == myValue) | |
25757 | ||
25758 | ||
25759 | ||
25760 | {setverdict(pass);} else {setverdict(fail);} | |
25761 | ||
25762 | ||
25763 | <RESULT> | |
25764 | ||
25765 | Overall verdict: pass | |
25766 | ||
25767 | <END_TC> | |
25768 | ||
25769 | :exmp. | |
25770 | ||
25771 | .*---------------------------------------------------------------------* | |
25772 | :h3. DECODING CER , TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT | |
25773 | .*---------------------------------------------------------------------* | |
25774 | :xmp tab=0. | |
25775 | ||
25776 | <TC - DECODING CER , TAGGED SEQUENCE (both elements are used), EXPLICIT TAGGING ENVIRONMENT> | |
25777 | ||
25778 | <STATIC:ASN> | |
25779 | ||
25780 | TempA | |
25781 | ||
25782 | DEFINITIONS | |
25783 | ||
25784 | EXPLICIT TAGS | |
25785 | ||
25786 | ||
25787 | ::= | |
25788 | ||
25789 | BEGIN | |
25790 | ||
25791 | ||
25792 | BERPDU ::= [0] SEQUENCE | |
25793 | { | |
25794 | b BOOLEAN OPTIONAL, | |
25795 | c INTEGER OPTIONAL | |
25796 | } | |
25797 | ||
25798 | ||
25799 | END | |
25800 | ||
25801 | <STATIC> | |
25802 | ||
25803 | import from TempA all; | |
25804 | ||
25805 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25806 | ||
25807 | ||
25808 | const BERPDU myValue := {b := true, | |
25809 | c := 5 } | |
25810 | ||
25811 | ||
25812 | ||
25813 | <TTCN_TC:EXEC> | |
25814 | ||
25815 | if (dec_BER_PDU('A08030800101FF02010500000000'O) == myValue) | |
25816 | ||
25817 | ||
25818 | ||
25819 | {setverdict(pass);} else {setverdict(fail);} | |
25820 | ||
25821 | ||
25822 | <RESULT> | |
25823 | ||
25824 | Overall verdict: pass | |
25825 | ||
25826 | <END_TC> | |
25827 | ||
25828 | :exmp. | |
25829 | ||
25830 | .*---------------------------------------------------------------------* | |
25831 | :h3. DECODING DER, TAGGED SEQUENCE (both elements are TAGGED and used) | |
25832 | .*---------------------------------------------------------------------* | |
25833 | :xmp tab=0. | |
25834 | ||
25835 | <TC - DECODING DER, TAGGED SEQUENCE (both elements are TAGGED and used)> | |
25836 | ||
25837 | <STATIC:ASN> | |
25838 | ||
25839 | TempA | |
25840 | ||
25841 | DEFINITIONS | |
25842 | ||
25843 | ||
25844 | ||
25845 | ::= | |
25846 | ||
25847 | BEGIN | |
25848 | ||
25849 | ||
25850 | BERPDU ::= [0] SEQUENCE | |
25851 | { | |
25852 | b [0] BOOLEAN OPTIONAL, | |
25853 | c [1] INTEGER OPTIONAL | |
25854 | } | |
25855 | ||
25856 | ||
25857 | ||
25858 | END | |
25859 | ||
25860 | <STATIC> | |
25861 | ||
25862 | import from TempA all; | |
25863 | ||
25864 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25865 | ||
25866 | ||
25867 | const BERPDU myValue := {b := true, | |
25868 | c := 5 } | |
25869 | ||
25870 | ||
25871 | ||
25872 | <TTCN_TC:EXEC> | |
25873 | ||
25874 | if (dec_BER_PDU('A00C300AA0030101FFA103020105'O) == myValue) | |
25875 | ||
25876 | ||
25877 | ||
25878 | {setverdict(pass);} else {setverdict(fail);} | |
25879 | ||
25880 | ||
25881 | <RESULT> | |
25882 | ||
25883 | Overall verdict: pass | |
25884 | ||
25885 | <END_TC> | |
25886 | ||
25887 | :exmp. | |
25888 | ||
25889 | .*---------------------------------------------------------------------* | |
25890 | :h3. DECODING CER, TAGGED SEQUENCE (both elements are TAGGED and used) | |
25891 | .*---------------------------------------------------------------------* | |
25892 | :xmp tab=0. | |
25893 | ||
25894 | <TC - DECODING CER, TAGGED SEQUENCE (both elements are TAGGED and used)> | |
25895 | ||
25896 | <STATIC:ASN> | |
25897 | ||
25898 | TempA | |
25899 | ||
25900 | DEFINITIONS | |
25901 | ||
25902 | ||
25903 | ||
25904 | ::= | |
25905 | ||
25906 | BEGIN | |
25907 | ||
25908 | ||
25909 | BERPDU ::= [0] SEQUENCE | |
25910 | { | |
25911 | b [0] BOOLEAN OPTIONAL, | |
25912 | c [1] INTEGER OPTIONAL | |
25913 | } | |
25914 | ||
25915 | ||
25916 | ||
25917 | END | |
25918 | ||
25919 | <STATIC> | |
25920 | ||
25921 | import from TempA all; | |
25922 | ||
25923 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25924 | ||
25925 | ||
25926 | const BERPDU myValue := {b := true, | |
25927 | c := 5 } | |
25928 | ||
25929 | ||
25930 | ||
25931 | <TTCN_TC:EXEC> | |
25932 | ||
25933 | if (dec_BER_PDU('A0803080A0800101FF0000A180020105000000000000'O) == myValue) | |
25934 | ||
25935 | ||
25936 | ||
25937 | {setverdict(pass);} else {setverdict(fail);} | |
25938 | ||
25939 | ||
25940 | <RESULT> | |
25941 | ||
25942 | Overall verdict: pass | |
25943 | ||
25944 | <END_TC> | |
25945 | ||
25946 | :exmp. | |
25947 | ||
25948 | .*---------------------------------------------------------------------* | |
25949 | :h3. DECODING DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT | |
25950 | .*---------------------------------------------------------------------* | |
25951 | :xmp tab=0. | |
25952 | ||
25953 | <TC - DECODING DER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT> | |
25954 | ||
25955 | <STATIC:ASN> | |
25956 | ||
25957 | TempA | |
25958 | ||
25959 | DEFINITIONS | |
25960 | ||
25961 | EXPLICIT TAGS | |
25962 | ||
25963 | ||
25964 | ::= | |
25965 | ||
25966 | BEGIN | |
25967 | ||
25968 | ||
25969 | BERPDU ::= [0] SEQUENCE | |
25970 | { | |
25971 | b [0] BOOLEAN OPTIONAL, | |
25972 | c [1] INTEGER OPTIONAL | |
25973 | } | |
25974 | ||
25975 | ||
25976 | END | |
25977 | ||
25978 | <STATIC> | |
25979 | ||
25980 | import from TempA all; | |
25981 | ||
25982 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
25983 | ||
25984 | ||
25985 | const BERPDU myValue := {b := true, | |
25986 | c := 5 } | |
25987 | ||
25988 | ||
25989 | ||
25990 | <TTCN_TC:EXEC> | |
25991 | ||
25992 | if (dec_BER_PDU('A00C300AA0030101FFA103020105'O) == myValue) | |
25993 | ||
25994 | ||
25995 | ||
25996 | {setverdict(pass);} else {setverdict(fail);} | |
25997 | ||
25998 | ||
25999 | <RESULT> | |
26000 | ||
26001 | Overall verdict: pass | |
26002 | ||
26003 | <END_TC> | |
26004 | ||
26005 | :exmp. | |
26006 | ||
26007 | .*---------------------------------------------------------------------* | |
26008 | :h3. DECODING CER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT | |
26009 | .*---------------------------------------------------------------------* | |
26010 | :xmp tab=0. | |
26011 | ||
26012 | <TC - DECODING CER encoding of TAGGED SEQUENCE (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT> | |
26013 | ||
26014 | <STATIC:ASN> | |
26015 | ||
26016 | TempA | |
26017 | ||
26018 | DEFINITIONS | |
26019 | ||
26020 | EXPLICIT TAGS | |
26021 | ||
26022 | ||
26023 | ::= | |
26024 | ||
26025 | BEGIN | |
26026 | ||
26027 | ||
26028 | BERPDU ::= [0] SEQUENCE | |
26029 | { | |
26030 | b [0] BOOLEAN OPTIONAL, | |
26031 | c [1] INTEGER OPTIONAL | |
26032 | } | |
26033 | ||
26034 | ||
26035 | END | |
26036 | ||
26037 | <STATIC> | |
26038 | ||
26039 | import from TempA all; | |
26040 | ||
26041 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26042 | ||
26043 | ||
26044 | const BERPDU myValue := {b := true, | |
26045 | c := 5 } | |
26046 | ||
26047 | ||
26048 | ||
26049 | <TTCN_TC:EXEC> | |
26050 | ||
26051 | if (dec_BER_PDU('A0803080A0800101FF0000A180020105000000000000'O) == myValue) | |
26052 | ||
26053 | ||
26054 | ||
26055 | {setverdict(pass);} else {setverdict(fail);} | |
26056 | ||
26057 | ||
26058 | <RESULT> | |
26059 | ||
26060 | Overall verdict: pass | |
26061 | ||
26062 | <END_TC> | |
26063 | ||
26064 | :exmp. | |
26065 | ||
26066 | .*---------------------------------------------------------------------* | |
26067 | :h3. DECODING , DER , TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT | |
26068 | .*---------------------------------------------------------------------* | |
26069 | :xmp tab=0. | |
26070 | ||
26071 | <TC - DECODING , DER , TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT> | |
26072 | ||
26073 | <STATIC:ASN> | |
26074 | ||
26075 | TempA | |
26076 | ||
26077 | DEFINITIONS | |
26078 | ||
26079 | IMPLICIT TAGS | |
26080 | ||
26081 | ||
26082 | ::= | |
26083 | ||
26084 | BEGIN | |
26085 | ||
26086 | ||
26087 | BERPDU ::= [0] SEQUENCE | |
26088 | { | |
26089 | b [0] BOOLEAN OPTIONAL, | |
26090 | c [1] INTEGER OPTIONAL | |
26091 | } | |
26092 | ||
26093 | ||
26094 | END | |
26095 | ||
26096 | <STATIC> | |
26097 | ||
26098 | import from TempA all; | |
26099 | ||
26100 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26101 | ||
26102 | ||
26103 | const BERPDU myValue := {b := true, | |
26104 | c := 5 } | |
26105 | ||
26106 | ||
26107 | <TTCN_TC:EXEC> | |
26108 | ||
26109 | if (dec_BER_PDU('A0068001FF810105'O) == myValue) | |
26110 | ||
26111 | ||
26112 | ||
26113 | {setverdict(pass);} else {setverdict(fail);} | |
26114 | ||
26115 | ||
26116 | <RESULT> | |
26117 | ||
26118 | Overall verdict: pass | |
26119 | ||
26120 | <END_TC> | |
26121 | ||
26122 | :exmp. | |
26123 | ||
26124 | .*---------------------------------------------------------------------* | |
26125 | :h3. DECODING , CER , TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT | |
26126 | .*---------------------------------------------------------------------* | |
26127 | :xmp tab=0. | |
26128 | ||
26129 | <TC - DECODING , CER , TAGGED SEQUENCE (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT> | |
26130 | ||
26131 | <STATIC:ASN> | |
26132 | ||
26133 | TempA | |
26134 | ||
26135 | DEFINITIONS | |
26136 | ||
26137 | IMPLICIT TAGS | |
26138 | ||
26139 | ||
26140 | ::= | |
26141 | ||
26142 | BEGIN | |
26143 | ||
26144 | ||
26145 | BERPDU ::= [0] SEQUENCE | |
26146 | { | |
26147 | b [0] BOOLEAN OPTIONAL, | |
26148 | c [1] INTEGER OPTIONAL | |
26149 | } | |
26150 | ||
26151 | ||
26152 | END | |
26153 | ||
26154 | <STATIC> | |
26155 | ||
26156 | import from TempA all; | |
26157 | ||
26158 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26159 | ||
26160 | ||
26161 | const BERPDU myValue := {b := true, | |
26162 | c := 5 } | |
26163 | ||
26164 | ||
26165 | <TTCN_TC:EXEC> | |
26166 | ||
26167 | if (dec_BER_PDU('A0808001FF8101050000'O) == myValue) | |
26168 | ||
26169 | ||
26170 | ||
26171 | {setverdict(pass);} else {setverdict(fail);} | |
26172 | ||
26173 | ||
26174 | <RESULT> | |
26175 | ||
26176 | Overall verdict: pass | |
26177 | ||
26178 | <END_TC> | |
26179 | ||
26180 | :exmp. | |
26181 | ||
26182 | .*---------------------------------------------------------------------* | |
26183 | :h3. DECODING , DER , TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT | |
26184 | .*---------------------------------------------------------------------* | |
26185 | :xmp tab=0. | |
26186 | ||
26187 | <TC - DECODING , DER , TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT> | |
26188 | ||
26189 | <STATIC:ASN> | |
26190 | ||
26191 | TempA | |
26192 | ||
26193 | DEFINITIONS | |
26194 | ||
26195 | AUTOMATIC TAGS | |
26196 | ||
26197 | ||
26198 | ::= | |
26199 | ||
26200 | BEGIN | |
26201 | ||
26202 | ||
26203 | BERPDU ::= [0] SEQUENCE | |
26204 | { | |
26205 | b [0] BOOLEAN OPTIONAL, | |
26206 | c [1] INTEGER OPTIONAL | |
26207 | } | |
26208 | ||
26209 | ||
26210 | END | |
26211 | ||
26212 | <STATIC> | |
26213 | ||
26214 | import from TempA all; | |
26215 | ||
26216 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26217 | ||
26218 | ||
26219 | const BERPDU myValue := {b := true, | |
26220 | c := 5 } | |
26221 | ||
26222 | ||
26223 | <TTCN_TC:EXEC> | |
26224 | ||
26225 | if (dec_BER_PDU('A0068001FF810105'O) == myValue) | |
26226 | ||
26227 | ||
26228 | ||
26229 | {setverdict(pass);} else {setverdict(fail);} | |
26230 | ||
26231 | ||
26232 | <RESULT> | |
26233 | ||
26234 | Overall verdict: pass | |
26235 | ||
26236 | <END_TC> | |
26237 | ||
26238 | :exmp. | |
26239 | ||
26240 | .*---------------------------------------------------------------------* | |
26241 | :h3. DECODING , CER , TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT | |
26242 | .*---------------------------------------------------------------------* | |
26243 | :xmp tab=0. | |
26244 | ||
26245 | <TC - DECODING , CER , TAGGED SEQUENCE (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT> | |
26246 | ||
26247 | <STATIC:ASN> | |
26248 | ||
26249 | TempA | |
26250 | ||
26251 | DEFINITIONS | |
26252 | ||
26253 | AUTOMATIC TAGS | |
26254 | ||
26255 | ||
26256 | ::= | |
26257 | ||
26258 | BEGIN | |
26259 | ||
26260 | ||
26261 | BERPDU ::= [0] SEQUENCE | |
26262 | { | |
26263 | b [0] BOOLEAN OPTIONAL, | |
26264 | c [1] INTEGER OPTIONAL | |
26265 | } | |
26266 | ||
26267 | ||
26268 | END | |
26269 | ||
26270 | <STATIC> | |
26271 | ||
26272 | import from TempA all; | |
26273 | ||
26274 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26275 | ||
26276 | ||
26277 | const BERPDU myValue := {b := true, | |
26278 | c := 5 } | |
26279 | ||
26280 | ||
26281 | <TTCN_TC:EXEC> | |
26282 | ||
26283 | if (dec_BER_PDU('A0808001FF8101050000'O) == myValue) | |
26284 | ||
26285 | ||
26286 | ||
26287 | {setverdict(pass);} else {setverdict(fail);} | |
26288 | ||
26289 | ||
26290 | <RESULT> | |
26291 | ||
26292 | Overall verdict: pass | |
26293 | ||
26294 | <END_TC> | |
26295 | ||
26296 | :exmp. | |
26297 | ||
26298 | .*---------------------------------------------------------------------* | |
26299 | :h3. DECODING ,DER, SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT | |
26300 | .*---------------------------------------------------------------------* | |
26301 | :xmp tab=0. | |
26302 | ||
26303 | <TC - DECODING ,DER, SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT> | |
26304 | ||
26305 | <STATIC:ASN> | |
26306 | ||
26307 | TempA | |
26308 | ||
26309 | DEFINITIONS | |
26310 | ||
26311 | AUTOMATIC TAGS | |
26312 | ||
26313 | ||
26314 | ::= | |
26315 | ||
26316 | BEGIN | |
26317 | ||
26318 | ||
26319 | BERPDU ::= SEQUENCE | |
26320 | { | |
26321 | b [5] BOOLEAN OPTIONAL, | |
26322 | c INTEGER OPTIONAL | |
26323 | } | |
26324 | ||
26325 | ||
26326 | END | |
26327 | ||
26328 | <STATIC> | |
26329 | ||
26330 | import from TempA all; | |
26331 | ||
26332 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26333 | ||
26334 | ||
26335 | const BERPDU myValue := {b := true, | |
26336 | c := 5 } | |
26337 | ||
26338 | ||
26339 | <TTCN_TC:EXEC> | |
26340 | ||
26341 | if (dec_BER_PDU('30068501FF020105'O) == myValue) | |
26342 | ||
26343 | ||
26344 | ||
26345 | {setverdict(pass);} else {setverdict(fail);} | |
26346 | ||
26347 | ||
26348 | <RESULT> | |
26349 | ||
26350 | Overall verdict: pass | |
26351 | ||
26352 | <END_TC> | |
26353 | ||
26354 | :exmp. | |
26355 | ||
26356 | .*---------------------------------------------------------------------* | |
26357 | :h3. DECODING ,CER, SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT | |
26358 | .*---------------------------------------------------------------------* | |
26359 | :xmp tab=0. | |
26360 | ||
26361 | <TC - DECODING ,CER, SEQUENCE , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT> | |
26362 | ||
26363 | <STATIC:ASN> | |
26364 | ||
26365 | TempA | |
26366 | ||
26367 | DEFINITIONS | |
26368 | ||
26369 | AUTOMATIC TAGS | |
26370 | ||
26371 | ||
26372 | ::= | |
26373 | ||
26374 | BEGIN | |
26375 | ||
26376 | ||
26377 | BERPDU ::= SEQUENCE | |
26378 | { | |
26379 | b [5] BOOLEAN OPTIONAL, | |
26380 | c INTEGER OPTIONAL | |
26381 | } | |
26382 | ||
26383 | ||
26384 | END | |
26385 | ||
26386 | <STATIC> | |
26387 | ||
26388 | import from TempA all; | |
26389 | ||
26390 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26391 | ||
26392 | ||
26393 | const BERPDU myValue := {b := true, | |
26394 | c := 5 } | |
26395 | ||
26396 | ||
26397 | <TTCN_TC:EXEC> | |
26398 | ||
26399 | if (dec_BER_PDU('30808501FF0201050000'O) == myValue) | |
26400 | ||
26401 | ||
26402 | ||
26403 | {setverdict(pass);} else {setverdict(fail);} | |
26404 | ||
26405 | ||
26406 | <RESULT> | |
26407 | ||
26408 | Overall verdict: pass | |
26409 | ||
26410 | <END_TC> | |
26411 | ||
26412 | :exmp. | |
26413 | ||
26414 | .*---------------------------------------------------------------------* | |
26415 | :h3. DECODING ,DER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags | |
26416 | .*---------------------------------------------------------------------* | |
26417 | :xmp tab=0. | |
26418 | ||
26419 | <TC - DECODING ,DER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags> | |
26420 | ||
26421 | <STATIC:ASN> | |
26422 | ||
26423 | TempA | |
26424 | ||
26425 | DEFINITIONS | |
26426 | ||
26427 | AUTOMATIC TAGS | |
26428 | ||
26429 | ||
26430 | ::= | |
26431 | ||
26432 | BEGIN | |
26433 | ||
26434 | MySeq ::= SEQUENCE | |
26435 | {x INTEGER OPTIONAL, | |
26436 | y OCTET STRING} | |
26437 | ||
26438 | ||
26439 | ||
26440 | BERPDU ::= SEQUENCE | |
26441 | { | |
26442 | b BOOLEAN OPTIONAL, | |
26443 | c INTEGER OPTIONAL, | |
26444 | COMPONENTS OF MySeq | |
26445 | } | |
26446 | ||
26447 | ||
26448 | END | |
26449 | ||
26450 | <STATIC> | |
26451 | ||
26452 | import from TempA all; | |
26453 | ||
26454 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26455 | ||
26456 | ||
26457 | const BERPDU myValue := {b := true, | |
26458 | c := 5 , | |
26459 | x := 6, | |
26460 | y := 'FF'O } | |
26461 | ||
26462 | ||
26463 | ||
26464 | <TTCN_TC:EXEC> | |
26465 | ||
26466 | if (dec_BER_PDU('300C8001FF8101058201068301FF'O) == myValue) | |
26467 | ||
26468 | ||
26469 | ||
26470 | {setverdict(pass);} else {setverdict(fail);} | |
26471 | ||
26472 | ||
26473 | <RESULT> | |
26474 | ||
26475 | Overall verdict: pass | |
26476 | ||
26477 | <END_TC> | |
26478 | ||
26479 | :exmp. | |
26480 | ||
26481 | .*---------------------------------------------------------------------* | |
26482 | :h3. DECODING ,CER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags | |
26483 | .*---------------------------------------------------------------------* | |
26484 | :xmp tab=0. | |
26485 | ||
26486 | <TC - DECODING ,CER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags> | |
26487 | ||
26488 | <STATIC:ASN> | |
26489 | ||
26490 | TempA | |
26491 | ||
26492 | DEFINITIONS | |
26493 | ||
26494 | AUTOMATIC TAGS | |
26495 | ||
26496 | ||
26497 | ::= | |
26498 | ||
26499 | BEGIN | |
26500 | ||
26501 | ||
26502 | MySeq ::= SEQUENCE | |
26503 | {x INTEGER OPTIONAL, | |
26504 | y OCTET STRING} | |
26505 | ||
26506 | ||
26507 | ||
26508 | BERPDU ::= SEQUENCE | |
26509 | { | |
26510 | b BOOLEAN OPTIONAL, | |
26511 | c INTEGER OPTIONAL, | |
26512 | COMPONENTS OF MySeq | |
26513 | } | |
26514 | ||
26515 | ||
26516 | END | |
26517 | ||
26518 | <STATIC> | |
26519 | ||
26520 | import from TempA all; | |
26521 | ||
26522 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26523 | ||
26524 | const BERPDU myValue := {b := true, | |
26525 | c := 5 , | |
26526 | x := 6, | |
26527 | y := 'FF'O } | |
26528 | ||
26529 | ||
26530 | ||
26531 | ||
26532 | <TTCN_TC:EXEC> | |
26533 | ||
26534 | if (dec_BER_PDU('30808001FF8101058201068301FF0000'O) == myValue) | |
26535 | ||
26536 | ||
26537 | ||
26538 | {setverdict(pass);} else {setverdict(fail);} | |
26539 | ||
26540 | ||
26541 | <RESULT> | |
26542 | ||
26543 | Overall verdict: pass | |
26544 | ||
26545 | <END_TC> | |
26546 | ||
26547 | :exmp. | |
26548 | ||
26549 | .*---------------------------------------------------------------------* | |
26550 | :h3. DECODING ,DER, SEQUENCE ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
26551 | .*---------------------------------------------------------------------* | |
26552 | :xmp tab=0. | |
26553 | ||
26554 | <TC - DECODING ,DER, SEQUENCE ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
26555 | ||
26556 | <STATIC:ASN> | |
26557 | ||
26558 | TempA | |
26559 | ||
26560 | DEFINITIONS | |
26561 | ||
26562 | AUTOMATIC TAGS | |
26563 | ||
26564 | ||
26565 | ::= | |
26566 | ||
26567 | BEGIN | |
26568 | ||
26569 | MySeq ::= SEQUENCE | |
26570 | {x [0] INTEGER OPTIONAL, | |
26571 | y OCTET STRING} | |
26572 | ||
26573 | ||
26574 | ||
26575 | BERPDU ::= SEQUENCE | |
26576 | { | |
26577 | b BOOLEAN OPTIONAL, | |
26578 | c INTEGER OPTIONAL, | |
26579 | COMPONENTS OF MySeq | |
26580 | } | |
26581 | ||
26582 | ||
26583 | ||
26584 | END | |
26585 | ||
26586 | <STATIC> | |
26587 | ||
26588 | import from TempA all; | |
26589 | ||
26590 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26591 | ||
26592 | ||
26593 | const BERPDU myValue := {b := true, | |
26594 | c := 5 , | |
26595 | x := 6, | |
26596 | y := 'FF'O } | |
26597 | ||
26598 | ||
26599 | ||
26600 | <TTCN_TC:EXEC> | |
26601 | ||
26602 | if (dec_BER_PDU('300C8001FF8101058201068301FF'O) == myValue) | |
26603 | ||
26604 | ||
26605 | ||
26606 | {setverdict(pass);} else {setverdict(fail);} | |
26607 | ||
26608 | ||
26609 | <RESULT> | |
26610 | ||
26611 | Overall verdict: pass | |
26612 | ||
26613 | <END_TC> | |
26614 | ||
26615 | :exmp. | |
26616 | ||
26617 | .*---------------------------------------------------------------------* | |
26618 | :h3. DECODING ,CER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags | |
26619 | .*---------------------------------------------------------------------* | |
26620 | :xmp tab=0. | |
26621 | ||
26622 | <TC - DECODING ,CER, SEQUENCE ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags> | |
26623 | ||
26624 | <STATIC:ASN> | |
26625 | ||
26626 | TempA | |
26627 | ||
26628 | DEFINITIONS | |
26629 | ||
26630 | AUTOMATIC TAGS | |
26631 | ||
26632 | ||
26633 | ::= | |
26634 | ||
26635 | BEGIN | |
26636 | ||
26637 | ||
26638 | MySeq ::= SEQUENCE | |
26639 | {x [0] INTEGER OPTIONAL, | |
26640 | y OCTET STRING} | |
26641 | ||
26642 | ||
26643 | ||
26644 | BERPDU ::= SEQUENCE | |
26645 | { | |
26646 | b BOOLEAN OPTIONAL, | |
26647 | c INTEGER OPTIONAL, | |
26648 | COMPONENTS OF MySeq | |
26649 | } | |
26650 | ||
26651 | ||
26652 | ||
26653 | ||
26654 | END | |
26655 | ||
26656 | <STATIC> | |
26657 | ||
26658 | import from TempA all; | |
26659 | ||
26660 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26661 | ||
26662 | ||
26663 | const BERPDU myValue := {b := true, | |
26664 | c := 5 , | |
26665 | x := 6, | |
26666 | y := 'FF'O } | |
26667 | ||
26668 | ||
26669 | ||
26670 | <TTCN_TC:EXEC> | |
26671 | ||
26672 | if (dec_BER_PDU('30808001FF8101058201068301FF0000'O) == myValue) | |
26673 | ||
26674 | ||
26675 | ||
26676 | {setverdict(pass);} else {setverdict(fail);} | |
26677 | ||
26678 | ||
26679 | <RESULT> | |
26680 | ||
26681 | Overall verdict: pass | |
26682 | ||
26683 | <END_TC> | |
26684 | ||
26685 | :exmp. | |
26686 | ||
26687 | .*---------------------------------------------------------------------* | |
26688 | :h3. DECODING ,DER, SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
26689 | .*---------------------------------------------------------------------* | |
26690 | :xmp tab=0. | |
26691 | ||
26692 | <TC - DECODING ,DER, SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
26693 | ||
26694 | <STATIC:ASN> | |
26695 | ||
26696 | TempA | |
26697 | ||
26698 | DEFINITIONS | |
26699 | ||
26700 | AUTOMATIC TAGS | |
26701 | ||
26702 | ||
26703 | ::= | |
26704 | ||
26705 | BEGIN | |
26706 | ||
26707 | ||
26708 | MySeq ::= SEQUENCE | |
26709 | {x INTEGER OPTIONAL, | |
26710 | y OCTET STRING} | |
26711 | ||
26712 | ||
26713 | ||
26714 | BERPDU ::= SEQUENCE | |
26715 | { | |
26716 | b [0] BOOLEAN OPTIONAL, | |
26717 | c BIT STRING OPTIONAL, | |
26718 | COMPONENTS OF MySeq | |
26719 | } | |
26720 | ||
26721 | END | |
26722 | ||
26723 | <STATIC> | |
26724 | ||
26725 | import from TempA all; | |
26726 | ||
26727 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26728 | ||
26729 | ||
26730 | ||
26731 | const BERPDU myValue := {b := true, | |
26732 | c := '1'B , | |
26733 | x := 6, | |
26734 | y := 'FF'O } | |
26735 | ||
26736 | ||
26737 | <TTCN_TC:EXEC> | |
26738 | ||
26739 | if (dec_BER_PDU('300D8001FF030207800201060401FF'O) == myValue) | |
26740 | ||
26741 | ||
26742 | ||
26743 | {setverdict(pass);} else {setverdict(fail);} | |
26744 | ||
26745 | ||
26746 | <RESULT> | |
26747 | ||
26748 | Overall verdict: pass | |
26749 | ||
26750 | <END_TC> | |
26751 | ||
26752 | :exmp. | |
26753 | ||
26754 | .*---------------------------------------------------------------------* | |
26755 | :h3. DECODING ,CER, SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
26756 | .*---------------------------------------------------------------------* | |
26757 | :xmp tab=0. | |
26758 | ||
26759 | <TC - DECODING ,CER, SEQUENCE , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
26760 | ||
26761 | <STATIC:ASN> | |
26762 | ||
26763 | TempA | |
26764 | ||
26765 | DEFINITIONS | |
26766 | ||
26767 | AUTOMATIC TAGS | |
26768 | ||
26769 | ||
26770 | ::= | |
26771 | ||
26772 | BEGIN | |
26773 | ||
26774 | ||
26775 | MySeq ::= SEQUENCE | |
26776 | {x INTEGER OPTIONAL, | |
26777 | y OCTET STRING} | |
26778 | ||
26779 | ||
26780 | ||
26781 | BERPDU ::= SEQUENCE | |
26782 | { | |
26783 | b [0] BOOLEAN OPTIONAL, | |
26784 | c BIT STRING OPTIONAL, | |
26785 | COMPONENTS OF MySeq | |
26786 | } | |
26787 | ||
26788 | ||
26789 | ||
26790 | ||
26791 | END | |
26792 | ||
26793 | <STATIC> | |
26794 | ||
26795 | import from TempA all; | |
26796 | ||
26797 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26798 | ||
26799 | ||
26800 | const BERPDU myValue := {b := true, | |
26801 | c := '1'B , | |
26802 | x := 6, | |
26803 | y := 'FF'O } | |
26804 | ||
26805 | ||
26806 | <TTCN_TC:EXEC> | |
26807 | ||
26808 | if (dec_BER_PDU('30808001FF030207800201060401FF0000'O) == myValue) | |
26809 | ||
26810 | ||
26811 | ||
26812 | {setverdict(pass);} else {setverdict(fail);} | |
26813 | ||
26814 | ||
26815 | <RESULT> | |
26816 | ||
26817 | Overall verdict: pass | |
26818 | ||
26819 | <END_TC> | |
26820 | ||
26821 | :exmp. | |
26822 | ||
26823 | .*---------------------------------------------------------------------* | |
26824 | :h3. DECODING ,DER, SEQUENCE , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
26825 | .*---------------------------------------------------------------------* | |
26826 | :xmp tab=0. | |
26827 | ||
26828 | <TC - DECODING ,DER, SEQUENCE , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
26829 | ||
26830 | <STATIC:ASN> | |
26831 | ||
26832 | TempA | |
26833 | ||
26834 | DEFINITIONS | |
26835 | ||
26836 | AUTOMATIC TAGS | |
26837 | ||
26838 | ||
26839 | ::= | |
26840 | ||
26841 | BEGIN | |
26842 | ||
26843 | ||
26844 | MySeq ::= SEQUENCE | |
26845 | {x [1] INTEGER OPTIONAL, | |
26846 | y OCTET STRING} | |
26847 | ||
26848 | ||
26849 | ||
26850 | BERPDU ::= SEQUENCE | |
26851 | { | |
26852 | b [0] BOOLEAN OPTIONAL, | |
26853 | c BIT STRING OPTIONAL, | |
26854 | COMPONENTS OF MySeq | |
26855 | } | |
26856 | ||
26857 | END | |
26858 | ||
26859 | <STATIC> | |
26860 | ||
26861 | import from TempA all; | |
26862 | ||
26863 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26864 | ||
26865 | ||
26866 | ||
26867 | const BERPDU myValue := {b := true, | |
26868 | c := '1'B , | |
26869 | x := 6, | |
26870 | y := 'FF'O } | |
26871 | ||
26872 | ||
26873 | ||
26874 | <TTCN_TC:EXEC> | |
26875 | ||
26876 | if (dec_BER_PDU('300D8001FF030207808101060401FF'O) == myValue) | |
26877 | ||
26878 | ||
26879 | ||
26880 | {setverdict(pass);} else {setverdict(fail);} | |
26881 | ||
26882 | ||
26883 | <RESULT> | |
26884 | ||
26885 | Overall verdict: pass | |
26886 | ||
26887 | <END_TC> | |
26888 | ||
26889 | :exmp. | |
26890 | ||
26891 | .*---------------------------------------------------------------------* | |
26892 | :h3. DECODING ,CER, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
26893 | .*---------------------------------------------------------------------* | |
26894 | :xmp tab=0. | |
26895 | ||
26896 | <TC - DECODING ,CER, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
26897 | ||
26898 | <STATIC:ASN> | |
26899 | ||
26900 | TempA | |
26901 | ||
26902 | DEFINITIONS | |
26903 | ||
26904 | AUTOMATIC TAGS | |
26905 | ||
26906 | ||
26907 | ::= | |
26908 | ||
26909 | BEGIN | |
26910 | ||
26911 | ||
26912 | MySeq ::= SEQUENCE | |
26913 | {x [1] INTEGER OPTIONAL, | |
26914 | y OCTET STRING} | |
26915 | ||
26916 | ||
26917 | ||
26918 | BERPDU ::= SEQUENCE | |
26919 | { | |
26920 | b [0] BOOLEAN OPTIONAL, | |
26921 | c BIT STRING OPTIONAL, | |
26922 | COMPONENTS OF MySeq | |
26923 | } | |
26924 | ||
26925 | ||
26926 | ||
26927 | ||
26928 | END | |
26929 | ||
26930 | <STATIC> | |
26931 | ||
26932 | import from TempA all; | |
26933 | ||
26934 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
26935 | ||
26936 | ||
26937 | const BERPDU myValue := {b := true, | |
26938 | c := '1'B , | |
26939 | x := 6, | |
26940 | y := 'FF'O } | |
26941 | ||
26942 | ||
26943 | ||
26944 | <TTCN_TC:EXEC> | |
26945 | ||
26946 | if (dec_BER_PDU('30808001FF030207808101060401FF0000'O) == myValue) | |
26947 | ||
26948 | ||
26949 | ||
26950 | {setverdict(pass);} else {setverdict(fail);} | |
26951 | ||
26952 | ||
26953 | <RESULT> | |
26954 | ||
26955 | Overall verdict: pass | |
26956 | ||
26957 | <END_TC> | |
26958 | ||
26959 | :exmp. | |
26960 | ||
26961 | .*---------------------------------------------------------------------* | |
26962 | :h3. DECODING ,DER, SEQUENCE with CHOICE element, AUTOMATIC TAGS | |
26963 | .*---------------------------------------------------------------------* | |
26964 | :xmp tab=0. | |
26965 | ||
26966 | <TC - DECODING ,DER, SEQUENCE with CHOICE element, AUTOMATIC TAGS> | |
26967 | ||
26968 | <STATIC:ASN> | |
26969 | ||
26970 | TempA | |
26971 | ||
26972 | DEFINITIONS | |
26973 | ||
26974 | AUTOMATIC TAGS | |
26975 | ||
26976 | ||
26977 | ::= | |
26978 | ||
26979 | BEGIN | |
26980 | ||
26981 | ||
26982 | BERPDU ::= SEQUENCE | |
26983 | { | |
26984 | b CHOICE { | |
26985 | x BOOLEAN, | |
26986 | y OCTET STRING | |
26987 | } | |
26988 | OPTIONAL, | |
26989 | ||
26990 | ||
26991 | c INTEGER OPTIONAL | |
26992 | ||
26993 | } | |
26994 | ||
26995 | ||
26996 | ||
26997 | END | |
26998 | ||
26999 | <STATIC> | |
27000 | ||
27001 | import from TempA all; | |
27002 | ||
27003 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
27004 | ||
27005 | ||
27006 | const BERPDU myValue := {b := {x := true}, | |
27007 | c := 4 | |
27008 | } | |
27009 | ||
27010 | ||
27011 | ||
27012 | <TTCN_TC:EXEC> | |
27013 | ||
27014 | if (dec_BER_PDU('3008A0038001FF810104'O) == myValue) | |
27015 | ||
27016 | ||
27017 | ||
27018 | {setverdict(pass);} else {setverdict(fail);} | |
27019 | ||
27020 | ||
27021 | <RESULT> | |
27022 | ||
27023 | Overall verdict: pass | |
27024 | ||
27025 | <END_TC> | |
27026 | ||
27027 | :exmp. | |
27028 | ||
27029 | .*---------------------------------------------------------------------* | |
27030 | :h3. DECODING ,CER, SEQUENCE with CHOICE element, AUTOMATIC TAGS | |
27031 | .*---------------------------------------------------------------------* | |
27032 | :xmp tab=0. | |
27033 | ||
27034 | <TC - DECODING ,CER, SEQUENCE with CHOICE element, AUTOMATIC TAGS> | |
27035 | ||
27036 | <STATIC:ASN> | |
27037 | ||
27038 | TempA | |
27039 | ||
27040 | DEFINITIONS | |
27041 | ||
27042 | AUTOMATIC TAGS | |
27043 | ||
27044 | ||
27045 | ::= | |
27046 | ||
27047 | BEGIN | |
27048 | ||
27049 | BERPDU ::= SEQUENCE | |
27050 | { | |
27051 | b CHOICE { | |
27052 | x BOOLEAN, | |
27053 | y OCTET STRING | |
27054 | } | |
27055 | OPTIONAL, | |
27056 | ||
27057 | ||
27058 | c INTEGER OPTIONAL | |
27059 | ||
27060 | } | |
27061 | ||
27062 | ||
27063 | END | |
27064 | ||
27065 | <STATIC> | |
27066 | ||
27067 | import from TempA all; | |
27068 | ||
27069 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
27070 | ||
27071 | ||
27072 | const BERPDU myValue := {b := {x := true}, | |
27073 | c := 4 | |
27074 | } | |
27075 | ||
27076 | ||
27077 | <TTCN_TC:EXEC> | |
27078 | ||
27079 | if (dec_BER_PDU('3080A0808001FF00008101040000'O) == myValue) | |
27080 | ||
27081 | ||
27082 | ||
27083 | {setverdict(pass);} else {setverdict(fail);} | |
27084 | ||
27085 | ||
27086 | <RESULT> | |
27087 | ||
27088 | Overall verdict: pass | |
27089 | ||
27090 | <END_TC> | |
27091 | ||
27092 | :exmp. | |
27093 | ||
27094 | .*---------------------------------------------------------------------* | |
27095 | :h3. DECODING ,DER, SEQUENCE with CHOICE element, | |
27096 | .*---------------------------------------------------------------------* | |
27097 | :xmp tab=0. | |
27098 | ||
27099 | <TC - DECODING ,DER, SEQUENCE with CHOICE element, > | |
27100 | ||
27101 | <STATIC:ASN> | |
27102 | ||
27103 | TempA | |
27104 | ||
27105 | DEFINITIONS | |
27106 | ||
27107 | ||
27108 | ||
27109 | ::= | |
27110 | ||
27111 | BEGIN | |
27112 | ||
27113 | ||
27114 | BERPDU ::= SEQUENCE | |
27115 | { | |
27116 | b CHOICE { | |
27117 | x BOOLEAN, | |
27118 | y OCTET STRING | |
27119 | } | |
27120 | OPTIONAL, | |
27121 | ||
27122 | ||
27123 | c INTEGER OPTIONAL | |
27124 | ||
27125 | } | |
27126 | ||
27127 | ||
27128 | END | |
27129 | ||
27130 | <STATIC> | |
27131 | ||
27132 | import from TempA all; | |
27133 | ||
27134 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
27135 | ||
27136 | const BERPDU myValue := {b := {x := true}, | |
27137 | c := 4 | |
27138 | } | |
27139 | ||
27140 | ||
27141 | ||
27142 | <TTCN_TC:EXEC> | |
27143 | ||
27144 | if (dec_BER_PDU('30060101FF020104'O) == myValue) | |
27145 | ||
27146 | ||
27147 | ||
27148 | {setverdict(pass);} else {setverdict(fail);} | |
27149 | ||
27150 | ||
27151 | <RESULT> | |
27152 | ||
27153 | Overall verdict: pass | |
27154 | ||
27155 | <END_TC> | |
27156 | ||
27157 | :exmp. | |
27158 | ||
27159 | .*---------------------------------------------------------------------* | |
27160 | :h3. DECODING ,CER, SEQUENCE with CHOICE element, | |
27161 | .*---------------------------------------------------------------------* | |
27162 | :xmp tab=0. | |
27163 | ||
27164 | <TC - DECODING ,CER, SEQUENCE with CHOICE element, > | |
27165 | ||
27166 | <STATIC:ASN> | |
27167 | ||
27168 | TempA | |
27169 | ||
27170 | DEFINITIONS | |
27171 | ||
27172 | ||
27173 | ||
27174 | ::= | |
27175 | ||
27176 | BEGIN | |
27177 | ||
27178 | ||
27179 | BERPDU ::= SEQUENCE | |
27180 | { | |
27181 | b CHOICE { | |
27182 | x BOOLEAN, | |
27183 | y OCTET STRING | |
27184 | } | |
27185 | OPTIONAL, | |
27186 | ||
27187 | ||
27188 | c INTEGER OPTIONAL | |
27189 | ||
27190 | } | |
27191 | ||
27192 | END | |
27193 | ||
27194 | <STATIC> | |
27195 | ||
27196 | import from TempA all; | |
27197 | ||
27198 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
27199 | ||
27200 | ||
27201 | const BERPDU myValue := {b := {x := true}, | |
27202 | c := 4 | |
27203 | } | |
27204 | ||
27205 | ||
27206 | <TTCN_TC:EXEC> | |
27207 | ||
27208 | if (dec_BER_PDU('30800101FF0201040000'O) == myValue) | |
27209 | ||
27210 | ||
27211 | ||
27212 | {setverdict(pass);} else {setverdict(fail);} | |
27213 | ||
27214 | ||
27215 | <RESULT> | |
27216 | ||
27217 | Overall verdict: pass | |
27218 | ||
27219 | <END_TC> | |
27220 | ||
27221 | :exmp. | |
27222 | ||
27223 | .*---------------------------------------------------------------------* | |
27224 | :h3. DECODING ,DER,SEQUENCE with EXTENSION , AUTOMATIC TAGS | |
27225 | .*---------------------------------------------------------------------* | |
27226 | :xmp tab=0. | |
27227 | ||
27228 | <TC - DECODING ,DER,SEQUENCE with EXTENSION , AUTOMATIC TAGS> | |
27229 | ||
27230 | <STATIC:ASN> | |
27231 | ||
27232 | TempA | |
27233 | ||
27234 | DEFINITIONS | |
27235 | ||
27236 | AUTOMATIC TAGS | |
27237 | ||
27238 | ::= | |
27239 | ||
27240 | BEGIN | |
27241 | ||
27242 | ||
27243 | ||
27244 | BERPDU ::= SEQUENCE | |
27245 | { | |
27246 | ||
27247 | a OCTET STRING, | |
27248 | ||
27249 | b BOOLEAN, | |
27250 | ||
27251 | ..., | |
27252 | ||
27253 | d BIT STRING, | |
27254 | ..., | |
27255 | ||
27256 | c INTEGER OPTIONAL | |
27257 | ||
27258 | } | |
27259 | ||
27260 | END | |
27261 | ||
27262 | <STATIC> | |
27263 | ||
27264 | import from TempA all; | |
27265 | ||
27266 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
27267 | ||
27268 | ||
27269 | const BERPDU myValue := { | |
27270 | a := 'FF'O, | |
27271 | b := true, | |
27272 | d := '1'B, | |
27273 | c := 4 | |
27274 | } | |
27275 | ||
27276 | <TTCN_TC:EXEC> | |
27277 | ||
27278 | if (dec_BER_PDU('300D8001FF8101FF83020780820104'O) == myValue) | |
27279 | ||
27280 | ||
27281 | ||
27282 | {setverdict(pass);} else {setverdict(fail);} | |
27283 | ||
27284 | ||
27285 | <RESULT> | |
27286 | ||
27287 | Overall verdict: pass | |
27288 | ||
27289 | <END_TC> | |
27290 | ||
27291 | :exmp. | |
27292 | ||
27293 | .*---------------------------------------------------------------------* | |
27294 | :h3. DECODING ,CER, SEQUENCE with EXTENSION , AUTOMATIC TAGS | |
27295 | .*---------------------------------------------------------------------* | |
27296 | :xmp tab=0. | |
27297 | ||
27298 | <TC - DECODING ,CER, SEQUENCE with EXTENSION , AUTOMATIC TAGS> | |
27299 | ||
27300 | <STATIC:ASN> | |
27301 | ||
27302 | TempA | |
27303 | ||
27304 | DEFINITIONS | |
27305 | ||
27306 | AUTOMATIC TAGS | |
27307 | ||
27308 | ::= | |
27309 | ||
27310 | BEGIN | |
27311 | ||
27312 | ||
27313 | ||
27314 | BERPDU ::= SEQUENCE | |
27315 | { | |
27316 | ||
27317 | a OCTET STRING, | |
27318 | ||
27319 | b BOOLEAN, | |
27320 | ||
27321 | ..., | |
27322 | ||
27323 | d BIT STRING, | |
27324 | ..., | |
27325 | ||
27326 | c INTEGER OPTIONAL | |
27327 | ||
27328 | } | |
27329 | ||
27330 | END | |
27331 | ||
27332 | <STATIC> | |
27333 | ||
27334 | import from TempA all; | |
27335 | ||
27336 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
27337 | ||
27338 | ||
27339 | const BERPDU myValue := { | |
27340 | a := 'FF'O, | |
27341 | b := true, | |
27342 | d := '1'B, | |
27343 | c := 4 | |
27344 | } | |
27345 | ||
27346 | <TTCN_TC:EXEC> | |
27347 | ||
27348 | if (dec_BER_PDU('30808001FF8101FF830207808201040000'O) == myValue) | |
27349 | ||
27350 | ||
27351 | ||
27352 | {setverdict(pass);} else {setverdict(fail);} | |
27353 | ||
27354 | ||
27355 | <RESULT> | |
27356 | ||
27357 | Overall verdict: pass | |
27358 | ||
27359 | <END_TC> | |
27360 | ||
27361 | :exmp. | |
27362 | ||
27363 | .*---------------------------------------------------------------------* | |
27364 | :h3. DECODING SEQUENCE with Long Form , AUTOMATIC TAGS | |
27365 | .*---------------------------------------------------------------------* | |
27366 | :xmp tab=0. | |
27367 | ||
27368 | <TC - DECODING SEQUENCE with Long Form , AUTOMATIC TAGS> | |
27369 | ||
27370 | <STATIC:ASN> | |
27371 | ||
27372 | TempA | |
27373 | ||
27374 | DEFINITIONS | |
27375 | ||
27376 | AUTOMATIC TAGS | |
27377 | ||
27378 | ::= | |
27379 | ||
27380 | BEGIN | |
27381 | ||
27382 | ||
27383 | ||
27384 | BERPDU ::= SEQUENCE | |
27385 | { | |
27386 | ||
27387 | a OCTET STRING, | |
27388 | ||
27389 | b BOOLEAN, | |
27390 | ||
27391 | ..., | |
27392 | ||
27393 | d BIT STRING, | |
27394 | ..., | |
27395 | ||
27396 | c INTEGER OPTIONAL | |
27397 | ||
27398 | } | |
27399 | ||
27400 | END | |
27401 | ||
27402 | <STATIC> | |
27403 | ||
27404 | import from TempA all; | |
27405 | ||
27406 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
27407 | ||
27408 | ||
27409 | const BERPDU myValue := { | |
27410 | a := 'FF'O, | |
27411 | b := true, | |
27412 | d := '1'B, | |
27413 | c := 4 | |
27414 | } | |
27415 | ||
27416 | <TTCN_TC:EXEC> | |
27417 | ||
27418 | if (dec_BER_PDU('308300000D8001FF8101FF83020780820104'O) == myValue) | |
27419 | ||
27420 | ||
27421 | ||
27422 | {setverdict(pass);} else {setverdict(fail);} | |
27423 | ||
27424 | ||
27425 | <RESULT> | |
27426 | ||
27427 | Overall verdict: pass | |
27428 | ||
27429 | <END_TC> | |
27430 | ||
27431 | :exmp. | |
27432 | ||
27433 | .*---------------------------------------------------------------------* | |
27434 | :h3. DECODING , DER, SEQUENCE with fields of different types , | |
27435 | .*---------------------------------------------------------------------* | |
27436 | :xmp tab=0. | |
27437 | ||
27438 | <TC - DECODING , DER, SEQUENCE with fields of different types ,> | |
27439 | ||
27440 | <STATIC:ASN> | |
27441 | ||
27442 | TempA | |
27443 | ||
27444 | DEFINITIONS | |
27445 | ||
27446 | ||
27447 | ::= | |
27448 | ||
27449 | BEGIN | |
27450 | ||
27451 | ||
27452 | BERPDU ::= SEQUENCE | |
27453 | { | |
27454 | a NULL, | |
27455 | b BOOLEAN, | |
27456 | c INTEGER, | |
27457 | d ENUMERATED {first ,second ,third}, | |
27458 | --e REAL, | |
27459 | f BIT STRING, | |
27460 | g OCTET STRING, | |
27461 | ||
27462 | h OBJECT IDENTIFIER, | |
27463 | i IA5String, | |
27464 | j CHOICE {x1 [1] BOOLEAN, | |
27465 | y1 [2] OCTET STRING}, | |
27466 | ||
27467 | k SEQUENCE{x2 NULL, | |
27468 | y2 BOOLEAN}, | |
27469 | ||
27470 | l SET { x3 BIT STRING, | |
27471 | y3 NULL}, | |
27472 | ||
27473 | m [3] SEQUENCE OF INTEGER, | |
27474 | n [4] SET OF BOOLEAN | |
27475 | } | |
27476 | ||
27477 | ||
27478 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
27479 | ||
27480 | ||
27481 | END | |
27482 | ||
27483 | <STATIC> | |
27484 | ||
27485 | import from TempA all; | |
27486 | ||
27487 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
27488 | ||
27489 | ||
27490 | const BERPDU myValue := {a := NULL, | |
27491 | b := true, | |
27492 | c := 2, | |
27493 | d := first, | |
27494 | // e := 1.0, | |
27495 | f := '1'B, | |
27496 | g := 'FFFF'O, | |
27497 | h := myOBJID, | |
27498 | i := "ABC", | |
27499 | j := {x1 := true } , | |
27500 | k := {x2 := NULL, | |
27501 | ||
27502 | y2 := true } , | |
27503 | l := {y3 := NULL , | |
27504 | ||
27505 | x3 := '1'B } , | |
27506 | m := | |
27507 | { 1 ,2 } , | |
27508 | n := | |
27509 | { true, true } | |
27510 | } | |
27511 | ||
27512 | ||
27513 | ||
27514 | ||
27515 | ||
27516 | <TTCN_TC:EXEC> | |
27517 | ||
27518 | if (dec_BER_PDU('304505000101FF0201020A0100030207800402FFFF06030002031603414243A1030101FF300505000101FF3106030207800500A3083006020101020102A40831060101FF0101FF'O) == myValue) | |
27519 | ||
27520 | ||
27521 | ||
27522 | {setverdict(pass);} else {setverdict(fail);} | |
27523 | ||
27524 | ||
27525 | <RESULT> | |
27526 | ||
27527 | Overall verdict: pass | |
27528 | ||
27529 | <END_TC> | |
27530 | ||
27531 | :exmp. | |
27532 | ||
27533 | .*---------------------------------------------------------------------* | |
27534 | :h3. DECODING , DER, SEQUENCE with fields of different types , | |
27535 | .*---------------------------------------------------------------------* | |
27536 | :xmp tab=0. | |
27537 | ||
27538 | <TC - DECODING , DER, SEQUENCE with fields of different types ,> | |
27539 | ||
27540 | <STATIC:ASN> | |
27541 | ||
27542 | TempA | |
27543 | ||
27544 | DEFINITIONS | |
27545 | ||
27546 | ||
27547 | ::= | |
27548 | ||
27549 | BEGIN | |
27550 | ||
27551 | ||
27552 | BERPDU ::= SEQUENCE | |
27553 | { | |
27554 | a NULL, | |
27555 | b BOOLEAN, | |
27556 | c INTEGER, | |
27557 | d ENUMERATED {first ,second ,third}, | |
27558 | -- e REAL, | |
27559 | f BIT STRING, | |
27560 | g OCTET STRING, | |
27561 | ||
27562 | h OBJECT IDENTIFIER, | |
27563 | i IA5String, | |
27564 | j CHOICE {x1 [1] BOOLEAN, | |
27565 | y1 [2] OCTET STRING}, | |
27566 | ||
27567 | k SEQUENCE{x2 NULL, | |
27568 | y2 BOOLEAN}, | |
27569 | ||
27570 | l SET { x3 BIT STRING, | |
27571 | y3 NULL}, | |
27572 | ||
27573 | m [3] SEQUENCE OF INTEGER, | |
27574 | n [4] SET OF BOOLEAN | |
27575 | } | |
27576 | ||
27577 | ||
27578 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
27579 | ||
27580 | ||
27581 | END | |
27582 | ||
27583 | <STATIC> | |
27584 | ||
27585 | import from TempA all; | |
27586 | ||
27587 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
27588 | ||
27589 | ||
27590 | const BERPDU myValue := {a := NULL, | |
27591 | b := true, | |
27592 | c := 2, | |
27593 | d := first, | |
27594 | // e := 1.0, 090603312E452B30 | |
27595 | f := '1'B, | |
27596 | g := 'FFFF'O, | |
27597 | h := myOBJID, | |
27598 | i := "ABC", | |
27599 | j := {x1 := true } , | |
27600 | k := {x2 := NULL, | |
27601 | ||
27602 | y2 := true } , | |
27603 | l := {y3 := NULL , | |
27604 | ||
27605 | x3 := '1'B } , | |
27606 | m := | |
27607 | { 1 ,2 } , | |
27608 | n := | |
27609 | { true, true } | |
27610 | } | |
27611 | ||
27612 | ||
27613 | ||
27614 | ||
27615 | ||
27616 | <TTCN_TC:EXEC> | |
27617 | ||
27618 | if (dec_BER_PDU('308005000101FF0201020A0100030207800402FFFF06030002031603414243A1800101FF0000308005000101FF000031800302078005000000A380308002010102010200000000A48031800101FF0101FF000000000000'O) == myValue) | |
27619 | ||
27620 | ||
27621 | ||
27622 | {setverdict(pass);} else {setverdict(fail);} | |
27623 | ||
27624 | ||
27625 | <RESULT> | |
27626 | ||
27627 | Overall verdict: pass | |
27628 | ||
27629 | <END_TC> | |
27630 | ||
27631 | :exmp. | |
27632 | ||
27633 | .*---------------------------------------------------------------------* | |
27634 | :h3. DECODING , DER, SEQUENCE with fields of different types , AUTOMATIC TAGS | |
27635 | .*---------------------------------------------------------------------* | |
27636 | :xmp tab=0. | |
27637 | ||
27638 | <TC - DECODING , DER, SEQUENCE with fields of different types , AUTOMATIC TAGS> | |
27639 | ||
27640 | <STATIC:ASN> | |
27641 | ||
27642 | TempA | |
27643 | ||
27644 | DEFINITIONS | |
27645 | AUTOMATIC TAGS | |
27646 | ||
27647 | ::= | |
27648 | ||
27649 | BEGIN | |
27650 | ||
27651 | ||
27652 | ||
27653 | BERPDU ::= SEQUENCE | |
27654 | { | |
27655 | a NULL, | |
27656 | b BOOLEAN, | |
27657 | c INTEGER, | |
27658 | d ENUMERATED {first ,second ,third}, | |
27659 | e NULL, | |
27660 | f BIT STRING, | |
27661 | g OCTET STRING, | |
27662 | ||
27663 | h OBJECT IDENTIFIER, | |
27664 | i IA5String, | |
27665 | j CHOICE {x1 BOOLEAN, | |
27666 | y1 OCTET STRING}, | |
27667 | ||
27668 | k SEQUENCE{x2 NULL, | |
27669 | y2 BOOLEAN}, | |
27670 | ||
27671 | l SET { x3 BIT STRING, | |
27672 | y3 NULL}, | |
27673 | ||
27674 | m SEQUENCE OF INTEGER, | |
27675 | n SET OF BOOLEAN | |
27676 | } | |
27677 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
27678 | ||
27679 | ||
27680 | END | |
27681 | ||
27682 | <STATIC> | |
27683 | ||
27684 | import from TempA all; | |
27685 | ||
27686 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
27687 | ||
27688 | ||
27689 | const BERPDU myValue := {a := NULL, | |
27690 | b := true, | |
27691 | c := 2, | |
27692 | d := first, | |
27693 | e := NULL, | |
27694 | f := '1'B, | |
27695 | g := 'FFFF'O, | |
27696 | h := myOBJID, | |
27697 | i := "ABC", | |
27698 | j := {x1 := true } , | |
27699 | k := {x2 := NULL, | |
27700 | ||
27701 | y2 := true } , | |
27702 | l := {y3 := NULL , | |
27703 | ||
27704 | x3 := '1'B } , | |
27705 | m := | |
27706 | { 1 ,2 } , | |
27707 | n := | |
27708 | { true, true } | |
27709 | } | |
27710 | ||
27711 | ||
27712 | ||
27713 | ||
27714 | ||
27715 | ||
27716 | <TTCN_TC:EXEC> | |
27717 | ||
27718 | if (dec_BER_PDU('304380008101FF8201028301008400850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB06800207808100AC06020101020102AD060101FF0101FF'O) == myValue) | |
27719 | ||
27720 | ||
27721 | ||
27722 | {setverdict(pass);} else {setverdict(fail);} | |
27723 | ||
27724 | ||
27725 | <RESULT> | |
27726 | ||
27727 | Overall verdict: pass | |
27728 | ||
27729 | <END_TC> | |
27730 | ||
27731 | :exmp. | |
27732 | ||
27733 | .*---------------------------------------------------------------------* | |
27734 | :h3. DECODING , DER, SEQUENCE with fields of different types ,AUTOMATIC TAGS | |
27735 | .*---------------------------------------------------------------------* | |
27736 | :xmp tab=0. | |
27737 | ||
27738 | <TC - DECODING , DER, SEQUENCE with fields of different types ,AUTOMATIC TAGS> | |
27739 | ||
27740 | <STATIC:ASN> | |
27741 | ||
27742 | TempA | |
27743 | ||
27744 | DEFINITIONS | |
27745 | ||
27746 | AUTOMATIC TAGS | |
27747 | ::= | |
27748 | ||
27749 | BEGIN | |
27750 | ||
27751 | ||
27752 | BERPDU ::= SEQUENCE | |
27753 | { | |
27754 | a NULL, | |
27755 | b BOOLEAN, | |
27756 | c INTEGER, | |
27757 | d ENUMERATED {first ,second ,third}, | |
27758 | e NULL, | |
27759 | f BIT STRING, | |
27760 | g OCTET STRING, | |
27761 | ||
27762 | h OBJECT IDENTIFIER, | |
27763 | i IA5String, | |
27764 | j CHOICE {x1 BOOLEAN, | |
27765 | y1 OCTET STRING}, | |
27766 | ||
27767 | k SEQUENCE{x2 NULL, | |
27768 | y2 BOOLEAN}, | |
27769 | ||
27770 | l SET { x3 BIT STRING, | |
27771 | y3 NULL}, | |
27772 | ||
27773 | m SEQUENCE OF INTEGER, | |
27774 | n SET OF BOOLEAN | |
27775 | } | |
27776 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
27777 | ||
27778 | ||
27779 | ||
27780 | END | |
27781 | ||
27782 | <STATIC> | |
27783 | ||
27784 | import from TempA all; | |
27785 | ||
27786 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
27787 | ||
27788 | ||
27789 | const BERPDU myValue := {a := NULL, | |
27790 | b := true, | |
27791 | c := 2, | |
27792 | d := first, | |
27793 | e := NULL, | |
27794 | f := '1'B, | |
27795 | g := 'FFFF'O, | |
27796 | h := myOBJID, | |
27797 | i := "ABC", | |
27798 | j := {x1 := true } , | |
27799 | k := {x2 := NULL, | |
27800 | ||
27801 | y2 := true } , | |
27802 | l := {y3 := NULL , | |
27803 | ||
27804 | x3 := '1'B } , | |
27805 | m := | |
27806 | { 1 ,2 } , | |
27807 | n := | |
27808 | { true, true } | |
27809 | } | |
27810 | ||
27811 | ||
27812 | ||
27813 | ||
27814 | ||
27815 | ||
27816 | <TTCN_TC:EXEC> | |
27817 | ||
27818 | if (dec_BER_PDU('308080008101FF8201028301008400850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB808002078081000000AC800201010201020000AD800101FF0101FF00000000'O) == myValue) | |
27819 | ||
27820 | ||
27821 | ||
27822 | {setverdict(pass);} else {setverdict(fail);} | |
27823 | ||
27824 | ||
27825 | <RESULT> | |
27826 | ||
27827 | Overall verdict: pass | |
27828 | ||
27829 | <END_TC> | |
27830 | ||
27831 | :exmp. | |
27832 | ||
27833 | .*---------------------------------------------------------------------* | |
27834 | :h3.CER + DER encoding of SEQUENCE OF INTEGER (empty) | |
27835 | .*---------------------------------------------------------------------* | |
27836 | :xmp tab=0. | |
27837 | ||
27838 | <TC - CER + DER encoding of SEQUENCE OF INTEGER (empty)> | |
27839 | ||
27840 | <STATIC:ASN> | |
27841 | ||
27842 | TempA | |
27843 | ||
27844 | DEFINITIONS ::= | |
27845 | BEGIN | |
27846 | ||
27847 | BERPDU ::= SEQUENCE OF INTEGER | |
27848 | ||
27849 | ||
27850 | ||
27851 | END | |
27852 | ||
27853 | <STATIC> | |
27854 | ||
27855 | import from TempA all; | |
27856 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
27857 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
27858 | ||
27859 | const BERPDU myValue := { } | |
27860 | ||
27861 | <TTCN_TC:EXEC> | |
27862 | ||
27863 | ||
27864 | ||
27865 | ||
27866 | if ((enc_DER_PDU(myValue) == '3000'O)and(enc_CER_PDU(myValue) == '30800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
27867 | ||
27868 | <RESULT> | |
27869 | ||
27870 | Overall verdict: pass | |
27871 | ||
27872 | <END_TC> | |
27873 | ||
27874 | :exmp. | |
27875 | ||
27876 | .*---------------------------------------------------------------------* | |
27877 | :h3.CER + DER encoding of SEQUENCE OF BOOLEAN | |
27878 | .*---------------------------------------------------------------------* | |
27879 | :xmp tab=0. | |
27880 | ||
27881 | <TC - CER + DER encoding of SEQUENCE OF BOOLEAN> | |
27882 | ||
27883 | <STATIC:ASN> | |
27884 | ||
27885 | TempA | |
27886 | ||
27887 | DEFINITIONS ::= | |
27888 | BEGIN | |
27889 | ||
27890 | BERPDU ::= SEQUENCE OF BOOLEAN | |
27891 | ||
27892 | ||
27893 | ||
27894 | END | |
27895 | ||
27896 | <STATIC> | |
27897 | ||
27898 | import from TempA all; | |
27899 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
27900 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
27901 | ||
27902 | const BERPDU myValue := {true, false } | |
27903 | ||
27904 | <TTCN_TC:EXEC> | |
27905 | ||
27906 | ||
27907 | ||
27908 | ||
27909 | if ((enc_DER_PDU(myValue) == '30060101FF010100'O)and(enc_CER_PDU(myValue) == '30800101FF0101000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
27910 | ||
27911 | <RESULT> | |
27912 | ||
27913 | Overall verdict: pass | |
27914 | ||
27915 | <END_TC> | |
27916 | ||
27917 | :exmp. | |
27918 | ||
27919 | .*---------------------------------------------------------------------* | |
27920 | :h3.CER + DER encoding of SEQUENCE OF OCTET STRING | |
27921 | .*---------------------------------------------------------------------* | |
27922 | :xmp tab=0. | |
27923 | ||
27924 | <TC - CER + DER encoding of SEQUENCE OF OCTET STRING > | |
27925 | ||
27926 | <STATIC:ASN> | |
27927 | ||
27928 | TempA | |
27929 | ||
27930 | DEFINITIONS ::= | |
27931 | BEGIN | |
27932 | ||
27933 | BERPDU ::= SEQUENCE OF OCTET STRING | |
27934 | ||
27935 | END | |
27936 | ||
27937 | <STATIC> | |
27938 | ||
27939 | import from TempA all; | |
27940 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
27941 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
27942 | ||
27943 | const BERPDU myValue := {'FFFF'O, 'AB'O }; | |
27944 | ||
27945 | <TTCN_TC:EXEC> | |
27946 | ||
27947 | if ((enc_DER_PDU(myValue) == '30070402FFFF0401AB'O)and(enc_CER_PDU(myValue) == '30800402FFFF0401AB0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
27948 | ||
27949 | <RESULT> | |
27950 | ||
27951 | Overall verdict: pass | |
27952 | ||
27953 | <END_TC> | |
27954 | ||
27955 | :exmp. | |
27956 | ||
27957 | .*---------------------------------------------------------------------* | |
27958 | :h3.CER + DER encoding of SEQUENCE OF SEQUENCE | |
27959 | .*---------------------------------------------------------------------* | |
27960 | :xmp tab=0. | |
27961 | ||
27962 | <TC - CER + DER encoding of SEQUENCE OF SEQUENCE > | |
27963 | ||
27964 | <STATIC:ASN> | |
27965 | ||
27966 | TempA | |
27967 | ||
27968 | DEFINITIONS ::= | |
27969 | BEGIN | |
27970 | ||
27971 | BERPDU ::= SEQUENCE OF SEQUENCE {a INTEGER, b BOOLEAN} | |
27972 | ||
27973 | END | |
27974 | ||
27975 | <STATIC> | |
27976 | ||
27977 | import from TempA all; | |
27978 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
27979 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
27980 | ||
27981 | const BERPDU myValue := { | |
27982 | { | |
27983 | a := 5, | |
27984 | b := true | |
27985 | }, | |
27986 | ||
27987 | { | |
27988 | a := 3, | |
27989 | b := false | |
27990 | } | |
27991 | ||
27992 | }; | |
27993 | ||
27994 | <TTCN_TC:EXEC> | |
27995 | ||
27996 | if ((enc_DER_PDU(myValue) == '301030060201050101FF3006020103010100'O)and(enc_CER_PDU(myValue) == '308030800201050101FF0000308002010301010000000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
27997 | ||
27998 | <RESULT> | |
27999 | ||
28000 | Overall verdict: pass | |
28001 | ||
28002 | <END_TC> | |
28003 | ||
28004 | :exmp. | |
28005 | ||
28006 | .*---------------------------------------------------------------------* | |
28007 | :h3.CER + DER encoding of SEQUENCE OF SET | |
28008 | .*---------------------------------------------------------------------* | |
28009 | :xmp tab=0. | |
28010 | ||
28011 | <TC - CER + DER encoding of SEQUENCE OF SET > | |
28012 | ||
28013 | <STATIC:ASN> | |
28014 | ||
28015 | TempA | |
28016 | ||
28017 | DEFINITIONS ::= | |
28018 | BEGIN | |
28019 | ||
28020 | BERPDU ::= SEQUENCE OF SET {a INTEGER, b BOOLEAN} | |
28021 | ||
28022 | END | |
28023 | ||
28024 | <STATIC> | |
28025 | ||
28026 | import from TempA all; | |
28027 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
28028 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
28029 | ||
28030 | const BERPDU myValue := { | |
28031 | { | |
28032 | a := 5, | |
28033 | b := true | |
28034 | }, | |
28035 | ||
28036 | { | |
28037 | a := 3, | |
28038 | b := false | |
28039 | } | |
28040 | ||
28041 | }; | |
28042 | ||
28043 | <TTCN_TC:EXEC> | |
28044 | ||
28045 | if ((enc_DER_PDU(myValue) == '301031060101FF0201053106010100020103'O)and(enc_CER_PDU(myValue) == '308031800101FF0201050000318001010002010300000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
28046 | ||
28047 | <RESULT> | |
28048 | ||
28049 | Overall verdict: pass | |
28050 | ||
28051 | <END_TC> | |
28052 | ||
28053 | :exmp. | |
28054 | ||
28055 | .*---------------------------------------------------------------------* | |
28056 | :h3.CER + DER encoding of SEQUENCE OF CHOICE | |
28057 | .*---------------------------------------------------------------------* | |
28058 | :xmp tab=0. | |
28059 | ||
28060 | <TC - CER + DER encoding of SEQUENCE OF CHOICE > | |
28061 | ||
28062 | <STATIC:ASN> | |
28063 | ||
28064 | TempA | |
28065 | ||
28066 | DEFINITIONS ::= | |
28067 | BEGIN | |
28068 | ||
28069 | BERPDU ::= SEQUENCE OF CHOICE{a INTEGER, b BOOLEAN} | |
28070 | ||
28071 | END | |
28072 | ||
28073 | <STATIC> | |
28074 | ||
28075 | import from TempA all; | |
28076 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
28077 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
28078 | ||
28079 | const BERPDU myValue := { | |
28080 | { | |
28081 | a := 5 | |
28082 | }, | |
28083 | ||
28084 | { | |
28085 | b := false | |
28086 | } | |
28087 | ||
28088 | }; | |
28089 | ||
28090 | <TTCN_TC:EXEC> | |
28091 | ||
28092 | if ((enc_DER_PDU(myValue) == '3006020105010100'O)and(enc_CER_PDU(myValue) == '30800201050101000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
28093 | ||
28094 | <RESULT> | |
28095 | ||
28096 | Overall verdict: pass | |
28097 | ||
28098 | <END_TC> | |
28099 | ||
28100 | :exmp. | |
28101 | ||
28102 | .*---------------------------------------------------------------------* | |
28103 | :h3.CER + DER encoding of SEQUENCE OF SEQUENCE OF | |
28104 | .*---------------------------------------------------------------------* | |
28105 | :xmp tab=0. | |
28106 | ||
28107 | <TC - CER + DER encoding of SEQUENCE OF SEQUENCE OF> | |
28108 | ||
28109 | <STATIC:ASN> | |
28110 | ||
28111 | TempA | |
28112 | ||
28113 | DEFINITIONS ::= | |
28114 | BEGIN | |
28115 | ||
28116 | BERPDU ::= SEQUENCE OF SEQUENCE OF INTEGER | |
28117 | ||
28118 | END | |
28119 | ||
28120 | <STATIC> | |
28121 | ||
28122 | import from TempA all; | |
28123 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
28124 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
28125 | ||
28126 | const BERPDU myValue := { | |
28127 | { | |
28128 | 5, | |
28129 | 6, | |
28130 | 7 | |
28131 | }, | |
28132 | ||
28133 | { | |
28134 | 1, | |
28135 | 2, | |
28136 | 3 | |
28137 | } | |
28138 | }; | |
28139 | ||
28140 | <TTCN_TC:EXEC> | |
28141 | ||
28142 | if ((enc_DER_PDU(myValue) == '301630090201050201060201073009020101020102020103'O)and(enc_CER_PDU(myValue) == '308030800201050201060201070000308002010102010202010300000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
28143 | ||
28144 | <RESULT> | |
28145 | ||
28146 | Overall verdict: pass | |
28147 | ||
28148 | <END_TC> | |
28149 | ||
28150 | :exmp. | |
28151 | ||
28152 | .*---------------------------------------------------------------------* | |
28153 | :h3.CER + DER encoding of SEQUENCE OF SET OF | |
28154 | .*---------------------------------------------------------------------* | |
28155 | :xmp tab=0. | |
28156 | ||
28157 | <TC - CER + DER encoding of SEQUENCE OF SET OF> | |
28158 | ||
28159 | <STATIC:ASN> | |
28160 | ||
28161 | TempA | |
28162 | ||
28163 | DEFINITIONS ::= | |
28164 | BEGIN | |
28165 | ||
28166 | BERPDU ::= SEQUENCE OF SET OF INTEGER | |
28167 | ||
28168 | END | |
28169 | ||
28170 | <STATIC> | |
28171 | ||
28172 | import from TempA all; | |
28173 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
28174 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
28175 | ||
28176 | const BERPDU myValue := { | |
28177 | { | |
28178 | 5, | |
28179 | 6, | |
28180 | 7 | |
28181 | }, | |
28182 | ||
28183 | { | |
28184 | 1, | |
28185 | 2, | |
28186 | 3 | |
28187 | } | |
28188 | }; | |
28189 | ||
28190 | <TTCN_TC:EXEC> | |
28191 | ||
28192 | if ((enc_DER_PDU(myValue) == '301631090201050201060201073109020101020102020103'O)and(enc_CER_PDU(myValue) == '308031800201050201060201070000318002010102010202010300000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
28193 | ||
28194 | <RESULT> | |
28195 | ||
28196 | Overall verdict: pass | |
28197 | ||
28198 | <END_TC> | |
28199 | ||
28200 | :exmp. | |
28201 | ||
28202 | .*---------------------------------------------------------------------* | |
28203 | :h3.CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN | |
28204 | .*---------------------------------------------------------------------* | |
28205 | :xmp tab=0. | |
28206 | ||
28207 | <TC - CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN> | |
28208 | ||
28209 | <STATIC:ASN> | |
28210 | ||
28211 | TempA | |
28212 | ||
28213 | DEFINITIONS ::= | |
28214 | BEGIN | |
28215 | ||
28216 | BERPDU ::= [0] SEQUENCE OF BOOLEAN | |
28217 | ||
28218 | ||
28219 | ||
28220 | END | |
28221 | ||
28222 | <STATIC> | |
28223 | ||
28224 | import from TempA all; | |
28225 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
28226 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
28227 | ||
28228 | const BERPDU myValue := {true, false } | |
28229 | ||
28230 | <TTCN_TC:EXEC> | |
28231 | ||
28232 | ||
28233 | ||
28234 | ||
28235 | if ((enc_DER_PDU(myValue) == 'A00830060101FF010100'O)and(enc_CER_PDU(myValue) == 'A08030800101FF01010000000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
28236 | ||
28237 | <RESULT> | |
28238 | ||
28239 | Overall verdict: pass | |
28240 | ||
28241 | <END_TC> | |
28242 | ||
28243 | :exmp. | |
28244 | ||
28245 | .*---------------------------------------------------------------------* | |
28246 | :h3.CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING | |
28247 | .*---------------------------------------------------------------------* | |
28248 | :xmp tab=0. | |
28249 | ||
28250 | <TC - CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING> | |
28251 | ||
28252 | <STATIC:ASN> | |
28253 | ||
28254 | TempA | |
28255 | ||
28256 | DEFINITIONS | |
28257 | ||
28258 | EXPLICIT TAGS | |
28259 | ||
28260 | ::= | |
28261 | ||
28262 | BEGIN | |
28263 | ||
28264 | BERPDU ::= [0] SEQUENCE OF BOOLEAN | |
28265 | ||
28266 | ||
28267 | ||
28268 | END | |
28269 | ||
28270 | <STATIC> | |
28271 | ||
28272 | import from TempA all; | |
28273 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
28274 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
28275 | ||
28276 | const BERPDU myValue := {true, false } | |
28277 | ||
28278 | <TTCN_TC:EXEC> | |
28279 | ||
28280 | ||
28281 | ||
28282 | ||
28283 | if ((enc_DER_PDU(myValue) == 'A00830060101FF010100'O)and(enc_CER_PDU(myValue) == 'A08030800101FF01010000000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
28284 | ||
28285 | <RESULT> | |
28286 | ||
28287 | Overall verdict: pass | |
28288 | ||
28289 | <END_TC> | |
28290 | ||
28291 | :exmp. | |
28292 | ||
28293 | .*---------------------------------------------------------------------* | |
28294 | :h3.CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING | |
28295 | .*---------------------------------------------------------------------* | |
28296 | :xmp tab=0. | |
28297 | ||
28298 | <TC - CER + DER encoding of TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING> | |
28299 | ||
28300 | <STATIC:ASN> | |
28301 | ||
28302 | TempA | |
28303 | ||
28304 | DEFINITIONS | |
28305 | ||
28306 | IMPLICIT TAGS | |
28307 | ||
28308 | ::= | |
28309 | ||
28310 | BEGIN | |
28311 | ||
28312 | BERPDU ::= [0] SEQUENCE OF BOOLEAN | |
28313 | ||
28314 | ||
28315 | ||
28316 | END | |
28317 | ||
28318 | <STATIC> | |
28319 | ||
28320 | import from TempA all; | |
28321 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
28322 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
28323 | ||
28324 | const BERPDU myValue := {true, false } | |
28325 | ||
28326 | <TTCN_TC:EXEC> | |
28327 | ||
28328 | ||
28329 | ||
28330 | ||
28331 | if ((enc_DER_PDU(myValue) == 'A0060101FF010100'O)and(enc_CER_PDU(myValue) == 'A0800101FF0101000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
28332 | ||
28333 | <RESULT> | |
28334 | ||
28335 | Overall verdict: pass | |
28336 | ||
28337 | <END_TC> | |
28338 | ||
28339 | :exmp. | |
28340 | ||
28341 | .*---------------------------------------------------------------------* | |
28342 | :h3. DECODING DER, SEQUENCE OF INTEGER (empty) | |
28343 | .*---------------------------------------------------------------------* | |
28344 | :xmp tab=0. | |
28345 | ||
28346 | <TC - DECODING DER, SEQUENCE OF INTEGER (empty)> | |
28347 | ||
28348 | <STATIC:ASN> | |
28349 | ||
28350 | TempA | |
28351 | ||
28352 | DEFINITIONS ::= | |
28353 | BEGIN | |
28354 | ||
28355 | BERPDU ::= SEQUENCE OF INTEGER | |
28356 | ||
28357 | END | |
28358 | ||
28359 | <STATIC> | |
28360 | ||
28361 | import from TempA all; | |
28362 | ||
28363 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
28364 | ||
28365 | const BERPDU myValue := { } | |
28366 | ||
28367 | ||
28368 | <TTCN_TC:EXEC> | |
28369 | ||
28370 | if (dec_BER_PDU('3000'O) == myValue) | |
28371 | ||
28372 | {setverdict(pass);} else {setverdict(fail);} | |
28373 | ||
28374 | ||
28375 | <RESULT> | |
28376 | ||
28377 | Overall verdict: pass | |
28378 | ||
28379 | <END_TC> | |
28380 | ||
28381 | :exmp. | |
28382 | ||
28383 | .*---------------------------------------------------------------------* | |
28384 | :h3. DECODING CER, SEQUENCE OF INTEGER (empty) | |
28385 | .*---------------------------------------------------------------------* | |
28386 | :xmp tab=0. | |
28387 | ||
28388 | <TC - DECODING CER, SEQUENCE OF INTEGER (empty)> | |
28389 | ||
28390 | <STATIC:ASN> | |
28391 | ||
28392 | TempA | |
28393 | ||
28394 | DEFINITIONS ::= | |
28395 | BEGIN | |
28396 | ||
28397 | BERPDU ::= SEQUENCE OF INTEGER | |
28398 | ||
28399 | END | |
28400 | ||
28401 | <STATIC> | |
28402 | ||
28403 | import from TempA all; | |
28404 | ||
28405 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
28406 | ||
28407 | const BERPDU myValue := { } | |
28408 | ||
28409 | ||
28410 | <TTCN_TC:EXEC> | |
28411 | ||
28412 | if (dec_BER_PDU('30800000'O) == myValue) | |
28413 | ||
28414 | {setverdict(pass);} else {setverdict(fail);} | |
28415 | ||
28416 | ||
28417 | <RESULT> | |
28418 | ||
28419 | Overall verdict: pass | |
28420 | ||
28421 | <END_TC> | |
28422 | ||
28423 | :exmp. | |
28424 | ||
28425 | .*---------------------------------------------------------------------* | |
28426 | :h3. DECODING DER, SEQUENCE OF BOOLEAN | |
28427 | .*---------------------------------------------------------------------* | |
28428 | :xmp tab=0. | |
28429 | ||
28430 | <TC - DECODING DER, SEQUENCE OF BOOLEAN> | |
28431 | ||
28432 | <STATIC:ASN> | |
28433 | ||
28434 | TempA | |
28435 | ||
28436 | DEFINITIONS ::= | |
28437 | BEGIN | |
28438 | ||
28439 | BERPDU ::= SEQUENCE OF BOOLEAN | |
28440 | ||
28441 | END | |
28442 | ||
28443 | <STATIC> | |
28444 | ||
28445 | import from TempA all; | |
28446 | ||
28447 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
28448 | ||
28449 | const BERPDU myValue := {true, false } | |
28450 | ||
28451 | ||
28452 | <TTCN_TC:EXEC> | |
28453 | ||
28454 | if (dec_BER_PDU('30060101FF010100'O) == myValue) | |
28455 | ||
28456 | {setverdict(pass);} else {setverdict(fail);} | |
28457 | ||
28458 | ||
28459 | <RESULT> | |
28460 | ||
28461 | Overall verdict: pass | |
28462 | ||
28463 | <END_TC> | |
28464 | ||
28465 | :exmp. | |
28466 | ||
28467 | .*---------------------------------------------------------------------* | |
28468 | :h3. DECODING CER, SEQUENCE OF BOOLEAN | |
28469 | .*---------------------------------------------------------------------* | |
28470 | :xmp tab=0. | |
28471 | ||
28472 | <TC - DECODING CER, SEQUENCE OF BOOLEAN> | |
28473 | ||
28474 | <STATIC:ASN> | |
28475 | ||
28476 | TempA | |
28477 | ||
28478 | DEFINITIONS ::= | |
28479 | BEGIN | |
28480 | ||
28481 | BERPDU ::= SEQUENCE OF BOOLEAN | |
28482 | ||
28483 | END | |
28484 | ||
28485 | <STATIC> | |
28486 | ||
28487 | import from TempA all; | |
28488 | ||
28489 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
28490 | ||
28491 | const BERPDU myValue := {true, false } | |
28492 | ||
28493 | ||
28494 | <TTCN_TC:EXEC> | |
28495 | ||
28496 | if (dec_BER_PDU('30800101FF0101000000'O) == myValue) | |
28497 | ||
28498 | {setverdict(pass);} else {setverdict(fail);} | |
28499 | ||
28500 | ||
28501 | <RESULT> | |
28502 | ||
28503 | Overall verdict: pass | |
28504 | ||
28505 | <END_TC> | |
28506 | ||
28507 | :exmp. | |
28508 | ||
28509 | .*---------------------------------------------------------------------* | |
28510 | :h3. DECODING DER,SEQUENCE OF OCTET STRING | |
28511 | .*---------------------------------------------------------------------* | |
28512 | :xmp tab=0. | |
28513 | ||
28514 | <TC - DECODING DER,SEQUENCE OF OCTET STRING > | |
28515 | ||
28516 | <STATIC:ASN> | |
28517 | ||
28518 | TempA | |
28519 | ||
28520 | DEFINITIONS ::= | |
28521 | BEGIN | |
28522 | ||
28523 | BERPDU ::= SEQUENCE OF OCTET STRING | |
28524 | ||
28525 | END | |
28526 | ||
28527 | <STATIC> | |
28528 | ||
28529 | import from TempA all; | |
28530 | ||
28531 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
28532 | ||
28533 | const BERPDU myValue := {'FFFF'O, 'AB'O }; | |
28534 | ||
28535 | ||
28536 | <TTCN_TC:EXEC> | |
28537 | ||
28538 | if (dec_BER_PDU('30070402FFFF0401AB'O) == myValue) | |
28539 | ||
28540 | {setverdict(pass);} else {setverdict(fail);} | |
28541 | ||
28542 | ||
28543 | <RESULT> | |
28544 | ||
28545 | Overall verdict: pass | |
28546 | ||
28547 | <END_TC> | |
28548 | ||
28549 | :exmp. | |
28550 | ||
28551 | .*---------------------------------------------------------------------* | |
28552 | :h3. DECODING CER,SEQUENCE OF OCTET STRING | |
28553 | .*---------------------------------------------------------------------* | |
28554 | :xmp tab=0. | |
28555 | ||
28556 | <TC - DECODING CER,SEQUENCE OF OCTET STRING > | |
28557 | ||
28558 | <STATIC:ASN> | |
28559 | ||
28560 | TempA | |
28561 | ||
28562 | DEFINITIONS ::= | |
28563 | BEGIN | |
28564 | ||
28565 | BERPDU ::= SEQUENCE OF OCTET STRING | |
28566 | ||
28567 | END | |
28568 | ||
28569 | <STATIC> | |
28570 | ||
28571 | import from TempA all; | |
28572 | ||
28573 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
28574 | ||
28575 | const BERPDU myValue := {'FFFF'O, 'AB'O }; | |
28576 | ||
28577 | ||
28578 | <TTCN_TC:EXEC> | |
28579 | ||
28580 | if (dec_BER_PDU('30800402FFFF0401AB0000'O) == myValue) | |
28581 | ||
28582 | {setverdict(pass);} else {setverdict(fail);} | |
28583 | ||
28584 | ||
28585 | <RESULT> | |
28586 | ||
28587 | Overall verdict: pass | |
28588 | ||
28589 | <END_TC> | |
28590 | ||
28591 | :exmp. | |
28592 | ||
28593 | .*---------------------------------------------------------------------* | |
28594 | :h3. DECODING DER,SEQUENCE OF SEQUENCE | |
28595 | .*---------------------------------------------------------------------* | |
28596 | :xmp tab=0. | |
28597 | ||
28598 | <TC - DECODING DER,SEQUENCE OF SEQUENCE > | |
28599 | ||
28600 | <STATIC:ASN> | |
28601 | ||
28602 | TempA | |
28603 | ||
28604 | DEFINITIONS ::= | |
28605 | BEGIN | |
28606 | ||
28607 | BERPDU ::= SEQUENCE OF SEQUENCE {a INTEGER, b BOOLEAN} | |
28608 | ||
28609 | END | |
28610 | ||
28611 | <STATIC> | |
28612 | ||
28613 | import from TempA all; | |
28614 | ||
28615 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
28616 | ||
28617 | const BERPDU myValue := { | |
28618 | { | |
28619 | a := 5, | |
28620 | b := true | |
28621 | }, | |
28622 | ||
28623 | { | |
28624 | a := 3, | |
28625 | b := false | |
28626 | } | |
28627 | ||
28628 | }; | |
28629 | ||
28630 | ||
28631 | <TTCN_TC:EXEC> | |
28632 | ||
28633 | if (dec_BER_PDU('301030060201050101FF3006020103010100'O) == myValue) | |
28634 | ||
28635 | {setverdict(pass);} else {setverdict(fail);} | |
28636 | ||
28637 | ||
28638 | <RESULT> | |
28639 | ||
28640 | Overall verdict: pass | |
28641 | ||
28642 | <END_TC> | |
28643 | ||
28644 | :exmp. | |
28645 | ||
28646 | .*---------------------------------------------------------------------* | |
28647 | :h3. DECODING CER,SEQUENCE OF SEQUENCE | |
28648 | .*---------------------------------------------------------------------* | |
28649 | :xmp tab=0. | |
28650 | ||
28651 | <TC - DECODING CER,SEQUENCE OF SEQUENCE > | |
28652 | ||
28653 | <STATIC:ASN> | |
28654 | ||
28655 | TempA | |
28656 | ||
28657 | DEFINITIONS ::= | |
28658 | BEGIN | |
28659 | ||
28660 | BERPDU ::= SEQUENCE OF SEQUENCE {a INTEGER, b BOOLEAN} | |
28661 | ||
28662 | END | |
28663 | ||
28664 | <STATIC> | |
28665 | ||
28666 | import from TempA all; | |
28667 | ||
28668 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
28669 | ||
28670 | const BERPDU myValue := { | |
28671 | { | |
28672 | a := 5, | |
28673 | b := true | |
28674 | }, | |
28675 | ||
28676 | { | |
28677 | a := 3, | |
28678 | b := false | |
28679 | } | |
28680 | ||
28681 | }; | |
28682 | ||
28683 | ||
28684 | <TTCN_TC:EXEC> | |
28685 | ||
28686 | if (dec_BER_PDU('308030800201050101FF0000308002010301010000000000'O) == myValue) | |
28687 | ||
28688 | {setverdict(pass);} else {setverdict(fail);} | |
28689 | ||
28690 | ||
28691 | <RESULT> | |
28692 | ||
28693 | Overall verdict: pass | |
28694 | ||
28695 | <END_TC> | |
28696 | ||
28697 | :exmp. | |
28698 | ||
28699 | .*---------------------------------------------------------------------* | |
28700 | :h3. DECODING DER,SEQUENCE OF SET | |
28701 | .*---------------------------------------------------------------------* | |
28702 | :xmp tab=0. | |
28703 | ||
28704 | <TC - DECODING DER,SEQUENCE OF SET > | |
28705 | ||
28706 | <STATIC:ASN> | |
28707 | ||
28708 | TempA | |
28709 | ||
28710 | DEFINITIONS ::= | |
28711 | BEGIN | |
28712 | ||
28713 | BERPDU ::= SEQUENCE OF SET {a INTEGER, b BOOLEAN} | |
28714 | ||
28715 | END | |
28716 | ||
28717 | <STATIC> | |
28718 | ||
28719 | import from TempA all; | |
28720 | ||
28721 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
28722 | ||
28723 | const BERPDU myValue := { | |
28724 | { | |
28725 | a := 5, | |
28726 | b := true | |
28727 | }, | |
28728 | ||
28729 | { | |
28730 | a := 3, | |
28731 | b := false | |
28732 | } | |
28733 | ||
28734 | }; | |
28735 | ||
28736 | ||
28737 | <TTCN_TC:EXEC> | |
28738 | ||
28739 | if (dec_BER_PDU('301031060101FF0201053106010100020103'O) == myValue) | |
28740 | ||
28741 | {setverdict(pass);} else {setverdict(fail);} | |
28742 | ||
28743 | ||
28744 | <RESULT> | |
28745 | ||
28746 | Overall verdict: pass | |
28747 | ||
28748 | <END_TC> | |
28749 | ||
28750 | :exmp. | |
28751 | ||
28752 | .*---------------------------------------------------------------------* | |
28753 | :h3. DECODING CER,SEQUENCE OF SET | |
28754 | .*---------------------------------------------------------------------* | |
28755 | :xmp tab=0. | |
28756 | ||
28757 | <TC - DECODING CER,SEQUENCE OF SET > | |
28758 | ||
28759 | <STATIC:ASN> | |
28760 | ||
28761 | TempA | |
28762 | ||
28763 | DEFINITIONS ::= | |
28764 | BEGIN | |
28765 | ||
28766 | BERPDU ::= SEQUENCE OF SET {a INTEGER, b BOOLEAN} | |
28767 | ||
28768 | END | |
28769 | ||
28770 | <STATIC> | |
28771 | ||
28772 | import from TempA all; | |
28773 | ||
28774 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
28775 | ||
28776 | const BERPDU myValue := { | |
28777 | { | |
28778 | a := 5, | |
28779 | b := true | |
28780 | }, | |
28781 | ||
28782 | { | |
28783 | a := 3, | |
28784 | b := false | |
28785 | } | |
28786 | ||
28787 | }; | |
28788 | ||
28789 | ||
28790 | <TTCN_TC:EXEC> | |
28791 | ||
28792 | if (dec_BER_PDU('308031800101FF0201050000318001010002010300000000'O) == myValue) | |
28793 | ||
28794 | {setverdict(pass);} else {setverdict(fail);} | |
28795 | ||
28796 | ||
28797 | <RESULT> | |
28798 | ||
28799 | Overall verdict: pass | |
28800 | ||
28801 | <END_TC> | |
28802 | ||
28803 | :exmp. | |
28804 | ||
28805 | .*---------------------------------------------------------------------* | |
28806 | :h3. DECODING DER,SEQUENCE OF CHOICE | |
28807 | .*---------------------------------------------------------------------* | |
28808 | :xmp tab=0. | |
28809 | ||
28810 | <TC - DECODING DER,SEQUENCE OF CHOICE > | |
28811 | ||
28812 | <STATIC:ASN> | |
28813 | ||
28814 | TempA | |
28815 | ||
28816 | DEFINITIONS ::= | |
28817 | BEGIN | |
28818 | ||
28819 | BERPDU ::= SEQUENCE OF CHOICE{a INTEGER, b BOOLEAN} | |
28820 | ||
28821 | END | |
28822 | ||
28823 | <STATIC> | |
28824 | ||
28825 | import from TempA all; | |
28826 | ||
28827 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
28828 | ||
28829 | const BERPDU myValue := { | |
28830 | { | |
28831 | a := 5 | |
28832 | }, | |
28833 | ||
28834 | { | |
28835 | b := false | |
28836 | } | |
28837 | ||
28838 | }; | |
28839 | ||
28840 | ||
28841 | <TTCN_TC:EXEC> | |
28842 | ||
28843 | if (dec_BER_PDU('3006020105010100'O) == myValue) | |
28844 | ||
28845 | {setverdict(pass);} else {setverdict(fail);} | |
28846 | ||
28847 | ||
28848 | <RESULT> | |
28849 | ||
28850 | Overall verdict: pass | |
28851 | ||
28852 | <END_TC> | |
28853 | ||
28854 | :exmp. | |
28855 | ||
28856 | .*---------------------------------------------------------------------* | |
28857 | :h3. DECODING CER,SEQUENCE OF CHOICE | |
28858 | .*---------------------------------------------------------------------* | |
28859 | :xmp tab=0. | |
28860 | ||
28861 | <TC - DECODING CER,SEQUENCE OF CHOICE > | |
28862 | ||
28863 | <STATIC:ASN> | |
28864 | ||
28865 | TempA | |
28866 | ||
28867 | DEFINITIONS ::= | |
28868 | BEGIN | |
28869 | ||
28870 | BERPDU ::= SEQUENCE OF CHOICE{a INTEGER, b BOOLEAN} | |
28871 | ||
28872 | END | |
28873 | ||
28874 | <STATIC> | |
28875 | ||
28876 | import from TempA all; | |
28877 | ||
28878 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
28879 | ||
28880 | const BERPDU myValue := { | |
28881 | { | |
28882 | a := 5 | |
28883 | }, | |
28884 | ||
28885 | { | |
28886 | b := false | |
28887 | } | |
28888 | ||
28889 | }; | |
28890 | ||
28891 | ||
28892 | <TTCN_TC:EXEC> | |
28893 | ||
28894 | if (dec_BER_PDU('30800201050101000000'O) == myValue) | |
28895 | ||
28896 | {setverdict(pass);} else {setverdict(fail);} | |
28897 | ||
28898 | ||
28899 | <RESULT> | |
28900 | ||
28901 | Overall verdict: pass | |
28902 | ||
28903 | <END_TC> | |
28904 | ||
28905 | :exmp. | |
28906 | ||
28907 | .*---------------------------------------------------------------------* | |
28908 | :h3. DECODING DER,SEQUENCE OF SEQUENCE OF | |
28909 | .*---------------------------------------------------------------------* | |
28910 | :xmp tab=0. | |
28911 | ||
28912 | <TC - DECODING DER,SEQUENCE OF SEQUENCE OF> | |
28913 | ||
28914 | <STATIC:ASN> | |
28915 | ||
28916 | TempA | |
28917 | ||
28918 | DEFINITIONS ::= | |
28919 | BEGIN | |
28920 | ||
28921 | BERPDU ::= SEQUENCE OF SEQUENCE OF INTEGER | |
28922 | ||
28923 | END | |
28924 | ||
28925 | <STATIC> | |
28926 | ||
28927 | import from TempA all; | |
28928 | ||
28929 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
28930 | ||
28931 | const BERPDU myValue := { | |
28932 | { | |
28933 | 5, | |
28934 | 6, | |
28935 | 7 | |
28936 | }, | |
28937 | ||
28938 | { | |
28939 | 1, | |
28940 | 2, | |
28941 | 3 | |
28942 | } | |
28943 | }; | |
28944 | ||
28945 | ||
28946 | <TTCN_TC:EXEC> | |
28947 | ||
28948 | if (dec_BER_PDU('301630090201050201060201073009020101020102020103'O) == myValue) | |
28949 | ||
28950 | {setverdict(pass);} else {setverdict(fail);} | |
28951 | ||
28952 | ||
28953 | <RESULT> | |
28954 | ||
28955 | Overall verdict: pass | |
28956 | ||
28957 | <END_TC> | |
28958 | ||
28959 | :exmp. | |
28960 | ||
28961 | .*---------------------------------------------------------------------* | |
28962 | :h3. DECODING CER,SEQUENCE OF SEQUENCE OF | |
28963 | .*---------------------------------------------------------------------* | |
28964 | :xmp tab=0. | |
28965 | ||
28966 | <TC - DECODING CER,SEQUENCE OF SEQUENCE OF> | |
28967 | ||
28968 | <STATIC:ASN> | |
28969 | ||
28970 | TempA | |
28971 | ||
28972 | DEFINITIONS ::= | |
28973 | BEGIN | |
28974 | ||
28975 | BERPDU ::= SEQUENCE OF SEQUENCE OF INTEGER | |
28976 | ||
28977 | END | |
28978 | ||
28979 | <STATIC> | |
28980 | ||
28981 | import from TempA all; | |
28982 | ||
28983 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
28984 | ||
28985 | const BERPDU myValue := { | |
28986 | { | |
28987 | 5, | |
28988 | 6, | |
28989 | 7 | |
28990 | }, | |
28991 | ||
28992 | { | |
28993 | 1, | |
28994 | 2, | |
28995 | 3 | |
28996 | } | |
28997 | }; | |
28998 | ||
28999 | ||
29000 | <TTCN_TC:EXEC> | |
29001 | ||
29002 | if (dec_BER_PDU('308030800201050201060201070000308002010102010202010300000000'O) == myValue) | |
29003 | ||
29004 | {setverdict(pass);} else {setverdict(fail);} | |
29005 | ||
29006 | ||
29007 | <RESULT> | |
29008 | ||
29009 | Overall verdict: pass | |
29010 | ||
29011 | <END_TC> | |
29012 | ||
29013 | :exmp. | |
29014 | ||
29015 | .*---------------------------------------------------------------------* | |
29016 | :h3. DECODING DER,SEQUENCE OF SET OF | |
29017 | .*---------------------------------------------------------------------* | |
29018 | :xmp tab=0. | |
29019 | ||
29020 | <TC - DECODING DER,SEQUENCE OF SET OF> | |
29021 | ||
29022 | <STATIC:ASN> | |
29023 | ||
29024 | TempA | |
29025 | ||
29026 | DEFINITIONS ::= | |
29027 | BEGIN | |
29028 | ||
29029 | BERPDU ::= SEQUENCE OF SET OF INTEGER | |
29030 | ||
29031 | END | |
29032 | ||
29033 | <STATIC> | |
29034 | ||
29035 | import from TempA all; | |
29036 | ||
29037 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
29038 | ||
29039 | const BERPDU myValue := { | |
29040 | { | |
29041 | 5, | |
29042 | 6, | |
29043 | 7 | |
29044 | }, | |
29045 | ||
29046 | { | |
29047 | 1, | |
29048 | 2, | |
29049 | 3 | |
29050 | } | |
29051 | }; | |
29052 | ||
29053 | ||
29054 | <TTCN_TC:EXEC> | |
29055 | ||
29056 | if (dec_BER_PDU('301631090201050201060201073109020101020102020103'O) == myValue) | |
29057 | ||
29058 | {setverdict(pass);} else {setverdict(fail);} | |
29059 | ||
29060 | ||
29061 | <RESULT> | |
29062 | ||
29063 | Overall verdict: pass | |
29064 | ||
29065 | <END_TC> | |
29066 | ||
29067 | :exmp. | |
29068 | ||
29069 | .*---------------------------------------------------------------------* | |
29070 | :h3. DECODING CER,SEQUENCE OF SET OF | |
29071 | .*---------------------------------------------------------------------* | |
29072 | :xmp tab=0. | |
29073 | ||
29074 | <TC - DECODING CER,SEQUENCE OF SET OF> | |
29075 | ||
29076 | <STATIC:ASN> | |
29077 | ||
29078 | TempA | |
29079 | ||
29080 | DEFINITIONS ::= | |
29081 | BEGIN | |
29082 | ||
29083 | BERPDU ::= SEQUENCE OF SET OF INTEGER | |
29084 | ||
29085 | END | |
29086 | ||
29087 | <STATIC> | |
29088 | ||
29089 | import from TempA all; | |
29090 | ||
29091 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
29092 | ||
29093 | const BERPDU myValue := { | |
29094 | { | |
29095 | 5, | |
29096 | 6, | |
29097 | 7 | |
29098 | }, | |
29099 | ||
29100 | { | |
29101 | 1, | |
29102 | 2, | |
29103 | 3 | |
29104 | } | |
29105 | }; | |
29106 | ||
29107 | ||
29108 | <TTCN_TC:EXEC> | |
29109 | ||
29110 | if (dec_BER_PDU('308031800201050201060201070000318002010102010202010300000000'O) == myValue) | |
29111 | ||
29112 | {setverdict(pass);} else {setverdict(fail);} | |
29113 | ||
29114 | ||
29115 | <RESULT> | |
29116 | ||
29117 | Overall verdict: pass | |
29118 | ||
29119 | <END_TC> | |
29120 | ||
29121 | :exmp. | |
29122 | ||
29123 | .*---------------------------------------------------------------------* | |
29124 | :h3. DECODING DER,TAGGED SEQUENCE OF BOOLEAN | |
29125 | .*---------------------------------------------------------------------* | |
29126 | :xmp tab=0. | |
29127 | ||
29128 | <TC - DECODING DER,TAGGED SEQUENCE OF BOOLEAN> | |
29129 | ||
29130 | <STATIC:ASN> | |
29131 | ||
29132 | TempA | |
29133 | ||
29134 | DEFINITIONS ::= | |
29135 | BEGIN | |
29136 | ||
29137 | BERPDU ::= [0] SEQUENCE OF BOOLEAN | |
29138 | ||
29139 | END | |
29140 | ||
29141 | <STATIC> | |
29142 | ||
29143 | import from TempA all; | |
29144 | ||
29145 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
29146 | ||
29147 | const BERPDU myValue := {true, false } | |
29148 | ||
29149 | ||
29150 | <TTCN_TC:EXEC> | |
29151 | ||
29152 | if (dec_BER_PDU('A00830060101FF010100'O) == myValue) | |
29153 | ||
29154 | {setverdict(pass);} else {setverdict(fail);} | |
29155 | ||
29156 | ||
29157 | <RESULT> | |
29158 | ||
29159 | Overall verdict: pass | |
29160 | ||
29161 | <END_TC> | |
29162 | ||
29163 | :exmp. | |
29164 | ||
29165 | .*---------------------------------------------------------------------* | |
29166 | :h3. DECODING CER,TAGGED SEQUENCE OF BOOLEAN | |
29167 | .*---------------------------------------------------------------------* | |
29168 | :xmp tab=0. | |
29169 | ||
29170 | <TC - DECODING CER,TAGGED SEQUENCE OF BOOLEAN> | |
29171 | ||
29172 | <STATIC:ASN> | |
29173 | ||
29174 | TempA | |
29175 | ||
29176 | DEFINITIONS ::= | |
29177 | BEGIN | |
29178 | ||
29179 | BERPDU ::= [0] SEQUENCE OF BOOLEAN | |
29180 | ||
29181 | END | |
29182 | ||
29183 | <STATIC> | |
29184 | ||
29185 | import from TempA all; | |
29186 | ||
29187 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
29188 | ||
29189 | const BERPDU myValue := {true, false } | |
29190 | ||
29191 | ||
29192 | <TTCN_TC:EXEC> | |
29193 | ||
29194 | if (dec_BER_PDU('A08030800101FF01010000000000'O) == myValue) | |
29195 | ||
29196 | {setverdict(pass);} else {setverdict(fail);} | |
29197 | ||
29198 | ||
29199 | <RESULT> | |
29200 | ||
29201 | Overall verdict: pass | |
29202 | ||
29203 | <END_TC> | |
29204 | ||
29205 | :exmp. | |
29206 | ||
29207 | .*---------------------------------------------------------------------* | |
29208 | :h3. DECODING DER,TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING | |
29209 | .*---------------------------------------------------------------------* | |
29210 | :xmp tab=0. | |
29211 | ||
29212 | <TC - DECODING DER,TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING> | |
29213 | ||
29214 | <STATIC:ASN> | |
29215 | ||
29216 | TempA | |
29217 | ||
29218 | DEFINITIONS | |
29219 | ||
29220 | EXPLICIT TAGS | |
29221 | ::= | |
29222 | ||
29223 | BEGIN | |
29224 | ||
29225 | BERPDU ::= [0] SEQUENCE OF BOOLEAN | |
29226 | ||
29227 | END | |
29228 | ||
29229 | <STATIC> | |
29230 | ||
29231 | import from TempA all; | |
29232 | ||
29233 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
29234 | ||
29235 | const BERPDU myValue := {true, false } | |
29236 | ||
29237 | ||
29238 | <TTCN_TC:EXEC> | |
29239 | ||
29240 | if (dec_BER_PDU('A00830060101FF010100'O) == myValue) | |
29241 | ||
29242 | {setverdict(pass);} else {setverdict(fail);} | |
29243 | ||
29244 | ||
29245 | <RESULT> | |
29246 | ||
29247 | Overall verdict: pass | |
29248 | ||
29249 | <END_TC> | |
29250 | ||
29251 | :exmp. | |
29252 | ||
29253 | .*---------------------------------------------------------------------* | |
29254 | :h3. DECODING CER,TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING | |
29255 | .*---------------------------------------------------------------------* | |
29256 | :xmp tab=0. | |
29257 | ||
29258 | <TC - DECODING CER,TAGGED SEQUENCE OF BOOLEAN, EXPLICIT TAGGING> | |
29259 | ||
29260 | <STATIC:ASN> | |
29261 | ||
29262 | TempA | |
29263 | ||
29264 | DEFINITIONS | |
29265 | ||
29266 | EXPLICIT TAGS | |
29267 | ::= | |
29268 | ||
29269 | BEGIN | |
29270 | ||
29271 | BERPDU ::= [0] SEQUENCE OF BOOLEAN | |
29272 | ||
29273 | END | |
29274 | ||
29275 | <STATIC> | |
29276 | ||
29277 | import from TempA all; | |
29278 | ||
29279 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
29280 | ||
29281 | const BERPDU myValue := {true, false } | |
29282 | ||
29283 | ||
29284 | <TTCN_TC:EXEC> | |
29285 | ||
29286 | if (dec_BER_PDU('A08030800101FF01010000000000'O) == myValue) | |
29287 | ||
29288 | {setverdict(pass);} else {setverdict(fail);} | |
29289 | ||
29290 | ||
29291 | <RESULT> | |
29292 | ||
29293 | Overall verdict: pass | |
29294 | ||
29295 | <END_TC> | |
29296 | ||
29297 | :exmp. | |
29298 | ||
29299 | .*---------------------------------------------------------------------* | |
29300 | :h3. DECODING DER,TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING | |
29301 | .*---------------------------------------------------------------------* | |
29302 | :xmp tab=0. | |
29303 | ||
29304 | <TC - DECODING DER,TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING> | |
29305 | ||
29306 | <STATIC:ASN> | |
29307 | ||
29308 | TempA | |
29309 | ||
29310 | DEFINITIONS | |
29311 | ||
29312 | IMPLICIT TAGS | |
29313 | ::= | |
29314 | ||
29315 | BEGIN | |
29316 | ||
29317 | BERPDU ::= [0] SEQUENCE OF BOOLEAN | |
29318 | ||
29319 | END | |
29320 | ||
29321 | <STATIC> | |
29322 | ||
29323 | import from TempA all; | |
29324 | ||
29325 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
29326 | ||
29327 | const BERPDU myValue := {true, false } | |
29328 | ||
29329 | ||
29330 | <TTCN_TC:EXEC> | |
29331 | ||
29332 | if (dec_BER_PDU('A0060101FF010100'O) == myValue) | |
29333 | ||
29334 | {setverdict(pass);} else {setverdict(fail);} | |
29335 | ||
29336 | ||
29337 | <RESULT> | |
29338 | ||
29339 | Overall verdict: pass | |
29340 | ||
29341 | <END_TC> | |
29342 | ||
29343 | :exmp. | |
29344 | ||
29345 | .*---------------------------------------------------------------------* | |
29346 | :h3. DECODING CER,TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING | |
29347 | .*---------------------------------------------------------------------* | |
29348 | :xmp tab=0. | |
29349 | ||
29350 | <TC - DECODING CER,TAGGED SEQUENCE OF BOOLEAN, IMPLICIT TAGGING> | |
29351 | ||
29352 | <STATIC:ASN> | |
29353 | ||
29354 | TempA | |
29355 | ||
29356 | DEFINITIONS | |
29357 | ||
29358 | IMPLICIT TAGS | |
29359 | ::= | |
29360 | ||
29361 | BEGIN | |
29362 | ||
29363 | BERPDU ::= [0] SEQUENCE OF BOOLEAN | |
29364 | ||
29365 | END | |
29366 | ||
29367 | <STATIC> | |
29368 | ||
29369 | import from TempA all; | |
29370 | ||
29371 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
29372 | ||
29373 | const BERPDU myValue := {true, false } | |
29374 | ||
29375 | ||
29376 | <TTCN_TC:EXEC> | |
29377 | ||
29378 | if (dec_BER_PDU('A0800101FF0101000000'O) == myValue) | |
29379 | ||
29380 | {setverdict(pass);} else {setverdict(fail);} | |
29381 | ||
29382 | ||
29383 | <RESULT> | |
29384 | ||
29385 | Overall verdict: pass | |
29386 | ||
29387 | <END_TC> | |
29388 | ||
29389 | :exmp. | |
29390 | ||
29391 | .*---------------------------------------------------------------------* | |
29392 | :h3.CER + DER encoding of SET (EMPTY) | |
29393 | .*---------------------------------------------------------------------* | |
29394 | :xmp tab=0. | |
29395 | ||
29396 | <TC - CER + DER encoding of SET (EMPTY)> | |
29397 | ||
29398 | <STATIC:ASN> | |
29399 | ||
29400 | TempA | |
29401 | ||
29402 | DEFINITIONS ::= | |
29403 | BEGIN | |
29404 | ||
29405 | BERPDU ::= SET | |
29406 | { | |
29407 | b BOOLEAN OPTIONAL, | |
29408 | c INTEGER OPTIONAL | |
29409 | } | |
29410 | ||
29411 | ||
29412 | END | |
29413 | ||
29414 | <STATIC> | |
29415 | ||
29416 | import from TempA all; | |
29417 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
29418 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
29419 | ||
29420 | const BERPDU myValue := {b := omit, | |
29421 | c := omit } | |
29422 | ||
29423 | <TTCN_TC:EXEC> | |
29424 | ||
29425 | ||
29426 | ||
29427 | ||
29428 | if ((enc_DER_PDU(myValue) == '3100'O)and(enc_CER_PDU(myValue) == '31800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
29429 | ||
29430 | <RESULT> | |
29431 | ||
29432 | Overall verdict: pass | |
29433 | ||
29434 | <END_TC> | |
29435 | ||
29436 | :exmp. | |
29437 | ||
29438 | .*---------------------------------------------------------------------* | |
29439 | :h3.CER + DER encoding of SET (only one element is used) | |
29440 | .*---------------------------------------------------------------------* | |
29441 | :xmp tab=0. | |
29442 | ||
29443 | <TC - CER + DER encoding of SET (only one element is used)> | |
29444 | ||
29445 | <STATIC:ASN> | |
29446 | ||
29447 | TempA | |
29448 | ||
29449 | DEFINITIONS ::= | |
29450 | BEGIN | |
29451 | ||
29452 | BERPDU ::= SET | |
29453 | { | |
29454 | b BOOLEAN OPTIONAL, | |
29455 | c INTEGER OPTIONAL | |
29456 | } | |
29457 | ||
29458 | ||
29459 | END | |
29460 | ||
29461 | <STATIC> | |
29462 | ||
29463 | import from TempA all; | |
29464 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
29465 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
29466 | ||
29467 | const BERPDU myValue := {b := true, | |
29468 | c := omit } | |
29469 | ||
29470 | <TTCN_TC:EXEC> | |
29471 | ||
29472 | ||
29473 | ||
29474 | ||
29475 | if ((enc_DER_PDU(myValue) == '31030101FF'O)and(enc_CER_PDU(myValue) == '31800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
29476 | ||
29477 | <RESULT> | |
29478 | ||
29479 | Overall verdict: pass | |
29480 | ||
29481 | <END_TC> | |
29482 | ||
29483 | :exmp. | |
29484 | ||
29485 | .*---------------------------------------------------------------------* | |
29486 | :h3.CER + DER encoding of SET (both elements are used) | |
29487 | .*---------------------------------------------------------------------* | |
29488 | :xmp tab=0. | |
29489 | ||
29490 | <TC - CER + DER encoding of SET (both elements are used)> | |
29491 | ||
29492 | <STATIC:ASN> | |
29493 | ||
29494 | TempA | |
29495 | ||
29496 | DEFINITIONS ::= | |
29497 | BEGIN | |
29498 | ||
29499 | BERPDU ::= SET | |
29500 | { | |
29501 | b BOOLEAN OPTIONAL, | |
29502 | c INTEGER OPTIONAL | |
29503 | } | |
29504 | ||
29505 | ||
29506 | END | |
29507 | ||
29508 | <STATIC> | |
29509 | ||
29510 | import from TempA all; | |
29511 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
29512 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
29513 | ||
29514 | const BERPDU myValue := {b := true, | |
29515 | c := 5 } | |
29516 | ||
29517 | <TTCN_TC:EXEC> | |
29518 | ||
29519 | ||
29520 | ||
29521 | ||
29522 | if ((enc_DER_PDU(myValue) == '31060101FF020105'O)and(enc_CER_PDU(myValue) == '31800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
29523 | ||
29524 | <RESULT> | |
29525 | ||
29526 | Overall verdict: pass | |
29527 | ||
29528 | <END_TC> | |
29529 | ||
29530 | :exmp. | |
29531 | ||
29532 | .*---------------------------------------------------------------------* | |
29533 | :h3. encoding of SET(different order) (both elements are used) | |
29534 | .*---------------------------------------------------------------------* | |
29535 | :xmp tab=0. | |
29536 | ||
29537 | <TC - encoding of SET(different order) (both elements are used)> | |
29538 | ||
29539 | <STATIC:ASN> | |
29540 | ||
29541 | TempA | |
29542 | ||
29543 | DEFINITIONS ::= | |
29544 | BEGIN | |
29545 | ||
29546 | BERPDU ::= SET | |
29547 | { | |
29548 | b BOOLEAN OPTIONAL, | |
29549 | c INTEGER OPTIONAL | |
29550 | } | |
29551 | ||
29552 | ||
29553 | END | |
29554 | ||
29555 | <STATIC> | |
29556 | ||
29557 | import from TempA all; | |
29558 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
29559 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
29560 | ||
29561 | const BERPDU myValue := { c := 5, | |
29562 | b := true } | |
29563 | ||
29564 | <TTCN_TC:EXEC> | |
29565 | ||
29566 | ||
29567 | ||
29568 | ||
29569 | if ((enc_DER_PDU(myValue) == '31060101FF020105'O)and(enc_CER_PDU(myValue) == '31800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
29570 | ||
29571 | <RESULT> | |
29572 | ||
29573 | Overall verdict: pass | |
29574 | ||
29575 | <END_TC> | |
29576 | ||
29577 | :exmp. | |
29578 | ||
29579 | .*---------------------------------------------------------------------* | |
29580 | :h3.CER + DER encoding of SET (different order2)(both elements are used) | |
29581 | .*---------------------------------------------------------------------* | |
29582 | :xmp tab=0. | |
29583 | ||
29584 | <TC - CER + DER encoding of SET (different order2)(both elements are used)> | |
29585 | ||
29586 | <STATIC:ASN> | |
29587 | ||
29588 | TempA | |
29589 | ||
29590 | DEFINITIONS ::= | |
29591 | BEGIN | |
29592 | ||
29593 | BERPDU ::= SET | |
29594 | { | |
29595 | ||
29596 | c INTEGER OPTIONAL, | |
29597 | b BOOLEAN OPTIONAL | |
29598 | } | |
29599 | ||
29600 | ||
29601 | END | |
29602 | ||
29603 | <STATIC> | |
29604 | ||
29605 | import from TempA all; | |
29606 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
29607 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
29608 | ||
29609 | const BERPDU myValue := {b := true, | |
29610 | c := 5 } | |
29611 | ||
29612 | <TTCN_TC:EXEC> | |
29613 | ||
29614 | ||
29615 | ||
29616 | ||
29617 | if ((enc_DER_PDU(myValue) == '31060101FF020105'O)and(enc_CER_PDU(myValue) == '31800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
29618 | ||
29619 | <RESULT> | |
29620 | ||
29621 | Overall verdict: pass | |
29622 | ||
29623 | <END_TC> | |
29624 | ||
29625 | :exmp. | |
29626 | ||
29627 | .*---------------------------------------------------------------------* | |
29628 | :h3.CER + DER encoding of SET (one element is equal to Default) | |
29629 | .*---------------------------------------------------------------------* | |
29630 | :xmp tab=0. | |
29631 | ||
29632 | <TC - CER + DER encoding of SET (one element is equal to Default)> | |
29633 | ||
29634 | <STATIC:ASN> | |
29635 | ||
29636 | TempA | |
29637 | ||
29638 | DEFINITIONS ::= | |
29639 | BEGIN | |
29640 | ||
29641 | BERPDU ::= SET | |
29642 | { | |
29643 | b BOOLEAN DEFAULT TRUE, | |
29644 | c INTEGER OPTIONAL | |
29645 | } | |
29646 | ||
29647 | ||
29648 | END | |
29649 | ||
29650 | <STATIC> | |
29651 | ||
29652 | import from TempA all; | |
29653 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
29654 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
29655 | ||
29656 | const BERPDU myValue := {b := true, | |
29657 | c := 5 } | |
29658 | ||
29659 | <TTCN_TC:EXEC> | |
29660 | ||
29661 | ||
29662 | ||
29663 | ||
29664 | if ((enc_DER_PDU(myValue) == '3103020105'O)and(enc_CER_PDU(myValue) == '31800201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
29665 | ||
29666 | <RESULT> | |
29667 | ||
29668 | Overall verdict: pass | |
29669 | ||
29670 | <END_TC> | |
29671 | ||
29672 | :exmp. | |
29673 | ||
29674 | .*---------------------------------------------------------------------* | |
29675 | :h3. encoding of SET (different order)(one element is equal to Default) | |
29676 | .*---------------------------------------------------------------------* | |
29677 | :xmp tab=0. | |
29678 | ||
29679 | <TC - encoding of SET (different order)(one element is equal to Default)> | |
29680 | ||
29681 | <STATIC:ASN> | |
29682 | ||
29683 | TempA | |
29684 | ||
29685 | DEFINITIONS ::= | |
29686 | BEGIN | |
29687 | ||
29688 | BERPDU ::= SET | |
29689 | { | |
29690 | b BOOLEAN DEFAULT TRUE, | |
29691 | c INTEGER OPTIONAL | |
29692 | } | |
29693 | ||
29694 | ||
29695 | END | |
29696 | ||
29697 | <STATIC> | |
29698 | ||
29699 | import from TempA all; | |
29700 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
29701 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
29702 | ||
29703 | const BERPDU myValue := { | |
29704 | c := 5 , | |
29705 | b := true } | |
29706 | ||
29707 | <TTCN_TC:EXEC> | |
29708 | ||
29709 | ||
29710 | ||
29711 | ||
29712 | if ((enc_DER_PDU(myValue) == '3103020105'O)and(enc_CER_PDU(myValue) == '31800201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
29713 | ||
29714 | <RESULT> | |
29715 | ||
29716 | Overall verdict: pass | |
29717 | ||
29718 | <END_TC> | |
29719 | ||
29720 | :exmp. | |
29721 | ||
29722 | .*---------------------------------------------------------------------* | |
29723 | :h3.CER + DER encoding of SET (one element is not equal to Default) | |
29724 | .*---------------------------------------------------------------------* | |
29725 | :xmp tab=0. | |
29726 | ||
29727 | <TC - CER + DER encoding of SET (one element is not equal to Default)> | |
29728 | ||
29729 | <STATIC:ASN> | |
29730 | ||
29731 | TempA | |
29732 | ||
29733 | DEFINITIONS ::= | |
29734 | BEGIN | |
29735 | ||
29736 | BERPDU ::= SET | |
29737 | { | |
29738 | b BOOLEAN DEFAULT TRUE, | |
29739 | c INTEGER OPTIONAL | |
29740 | } | |
29741 | ||
29742 | ||
29743 | END | |
29744 | ||
29745 | <STATIC> | |
29746 | ||
29747 | import from TempA all; | |
29748 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
29749 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
29750 | ||
29751 | const BERPDU myValue := {b := false, | |
29752 | c := 5 } | |
29753 | ||
29754 | <TTCN_TC:EXEC> | |
29755 | ||
29756 | ||
29757 | ||
29758 | ||
29759 | if ((enc_DER_PDU(myValue) == '3106010100020105'O)and(enc_CER_PDU(myValue) == '31800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
29760 | ||
29761 | <RESULT> | |
29762 | ||
29763 | Overall verdict: pass | |
29764 | ||
29765 | <END_TC> | |
29766 | ||
29767 | :exmp. | |
29768 | ||
29769 | .*---------------------------------------------------------------------* | |
29770 | :h3. encoding of SET (different order) (one element is not equal to Default) | |
29771 | .*---------------------------------------------------------------------* | |
29772 | :xmp tab=0. | |
29773 | ||
29774 | <TC - encoding of SET (different order) (one element is not equal to Default)> | |
29775 | ||
29776 | <STATIC:ASN> | |
29777 | ||
29778 | TempA | |
29779 | ||
29780 | DEFINITIONS ::= | |
29781 | BEGIN | |
29782 | ||
29783 | BERPDU ::= SET | |
29784 | { | |
29785 | b BOOLEAN DEFAULT TRUE, | |
29786 | c INTEGER OPTIONAL | |
29787 | } | |
29788 | ||
29789 | ||
29790 | END | |
29791 | ||
29792 | <STATIC> | |
29793 | ||
29794 | import from TempA all; | |
29795 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
29796 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
29797 | ||
29798 | const BERPDU myValue := { | |
29799 | c := 5, | |
29800 | b := false } | |
29801 | ||
29802 | <TTCN_TC:EXEC> | |
29803 | ||
29804 | ||
29805 | ||
29806 | ||
29807 | if ((enc_DER_PDU(myValue) == '3106010100020105'O)and(enc_CER_PDU(myValue) == '31800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
29808 | ||
29809 | <RESULT> | |
29810 | ||
29811 | Overall verdict: pass | |
29812 | ||
29813 | <END_TC> | |
29814 | ||
29815 | :exmp. | |
29816 | ||
29817 | .*---------------------------------------------------------------------* | |
29818 | :h3. encoding of SET (different order2) (one element is not equal to Default) | |
29819 | .*---------------------------------------------------------------------* | |
29820 | :xmp tab=0. | |
29821 | ||
29822 | <TC - encoding of SET (different order2) (one element is not equal to Default)> | |
29823 | ||
29824 | <STATIC:ASN> | |
29825 | ||
29826 | TempA | |
29827 | ||
29828 | DEFINITIONS ::= | |
29829 | BEGIN | |
29830 | ||
29831 | BERPDU ::= SET | |
29832 | { | |
29833 | ||
29834 | c INTEGER OPTIONAL, | |
29835 | b BOOLEAN DEFAULT TRUE | |
29836 | } | |
29837 | ||
29838 | ||
29839 | END | |
29840 | ||
29841 | <STATIC> | |
29842 | ||
29843 | import from TempA all; | |
29844 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
29845 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
29846 | ||
29847 | const BERPDU myValue := { | |
29848 | c := 5, | |
29849 | b := false } | |
29850 | ||
29851 | <TTCN_TC:EXEC> | |
29852 | ||
29853 | ||
29854 | ||
29855 | ||
29856 | if ((enc_DER_PDU(myValue) == '3106010100020105'O)and(enc_CER_PDU(myValue) == '31800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
29857 | ||
29858 | <RESULT> | |
29859 | ||
29860 | Overall verdict: pass | |
29861 | ||
29862 | <END_TC> | |
29863 | ||
29864 | :exmp. | |
29865 | ||
29866 | .*---------------------------------------------------------------------* | |
29867 | :h3.CER + DER encoding of SET (EMPTY), AUTOMATIC TAGGING | |
29868 | .*---------------------------------------------------------------------* | |
29869 | :xmp tab=0. | |
29870 | ||
29871 | <TC - CER + DER encoding of SET (EMPTY), AUTOMATIC TAGGING> | |
29872 | ||
29873 | <STATIC:ASN> | |
29874 | ||
29875 | TempA | |
29876 | ||
29877 | DEFINITIONS | |
29878 | ||
29879 | AUTOMATIC TAGS | |
29880 | ||
29881 | ::= | |
29882 | ||
29883 | BEGIN | |
29884 | ||
29885 | BERPDU ::= SET | |
29886 | { | |
29887 | b BOOLEAN OPTIONAL, | |
29888 | c INTEGER OPTIONAL | |
29889 | } | |
29890 | ||
29891 | ||
29892 | END | |
29893 | ||
29894 | <STATIC> | |
29895 | ||
29896 | import from TempA all; | |
29897 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
29898 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
29899 | ||
29900 | const BERPDU myValue := {b := omit, | |
29901 | c := omit } | |
29902 | ||
29903 | <TTCN_TC:EXEC> | |
29904 | ||
29905 | ||
29906 | ||
29907 | ||
29908 | if ((enc_DER_PDU(myValue) == '3100'O)and(enc_CER_PDU(myValue) == '31800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
29909 | ||
29910 | <RESULT> | |
29911 | ||
29912 | Overall verdict: pass | |
29913 | ||
29914 | <END_TC> | |
29915 | ||
29916 | :exmp. | |
29917 | ||
29918 | .*---------------------------------------------------------------------* | |
29919 | :h3.CER + DER encoding of SET(only one element is used) AUTOMATIC TAGGING | |
29920 | .*---------------------------------------------------------------------* | |
29921 | :xmp tab=0. | |
29922 | ||
29923 | <TC - CER + DER encoding of SET(only one element is used) AUTOMATIC TAGGING> | |
29924 | ||
29925 | <STATIC:ASN> | |
29926 | ||
29927 | TempA | |
29928 | ||
29929 | DEFINITIONS | |
29930 | ||
29931 | AUTOMATIC TAGS | |
29932 | ||
29933 | ::= | |
29934 | ||
29935 | BEGIN | |
29936 | ||
29937 | BERPDU ::= SET | |
29938 | { | |
29939 | b BOOLEAN OPTIONAL, | |
29940 | c INTEGER OPTIONAL | |
29941 | } | |
29942 | ||
29943 | ||
29944 | END | |
29945 | ||
29946 | <STATIC> | |
29947 | ||
29948 | import from TempA all; | |
29949 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
29950 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
29951 | ||
29952 | const BERPDU myValue := {b := true, | |
29953 | c := omit } | |
29954 | ||
29955 | <TTCN_TC:EXEC> | |
29956 | ||
29957 | ||
29958 | ||
29959 | ||
29960 | if ((enc_DER_PDU(myValue) == '31038001FF'O)and(enc_CER_PDU(myValue) == '31808001FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
29961 | ||
29962 | <RESULT> | |
29963 | ||
29964 | Overall verdict: pass | |
29965 | ||
29966 | <END_TC> | |
29967 | ||
29968 | :exmp. | |
29969 | ||
29970 | .*---------------------------------------------------------------------* | |
29971 | :h3. encoding of SET (different order)(only one element is used) AUTOMATIC TAGGING | |
29972 | .*---------------------------------------------------------------------* | |
29973 | :xmp tab=0. | |
29974 | ||
29975 | <TC - encoding of SET (different order)(only one element is used) AUTOMATIC TAGGING> | |
29976 | ||
29977 | <STATIC:ASN> | |
29978 | ||
29979 | TempA | |
29980 | ||
29981 | DEFINITIONS | |
29982 | ||
29983 | AUTOMATIC TAGS | |
29984 | ||
29985 | ::= | |
29986 | ||
29987 | BEGIN | |
29988 | ||
29989 | BERPDU ::= SET | |
29990 | { | |
29991 | b BOOLEAN OPTIONAL, | |
29992 | c INTEGER OPTIONAL | |
29993 | } | |
29994 | ||
29995 | ||
29996 | END | |
29997 | ||
29998 | <STATIC> | |
29999 | ||
30000 | import from TempA all; | |
30001 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30002 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30003 | ||
30004 | const BERPDU myValue := { | |
30005 | c := omit, | |
30006 | b := true } | |
30007 | ||
30008 | <TTCN_TC:EXEC> | |
30009 | ||
30010 | ||
30011 | ||
30012 | ||
30013 | if ((enc_DER_PDU(myValue) == '31038001FF'O)and(enc_CER_PDU(myValue) == '31808001FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30014 | ||
30015 | <RESULT> | |
30016 | ||
30017 | Overall verdict: pass | |
30018 | ||
30019 | <END_TC> | |
30020 | ||
30021 | :exmp. | |
30022 | ||
30023 | .*---------------------------------------------------------------------* | |
30024 | :h3.CER + DER encoding of SET (both elements are used) AUTOMATIC TAGGING | |
30025 | .*---------------------------------------------------------------------* | |
30026 | :xmp tab=0. | |
30027 | ||
30028 | <TC - CER + DER encoding of SET (both elements are used) AUTOMATIC TAGGING> | |
30029 | ||
30030 | <STATIC:ASN> | |
30031 | ||
30032 | TempA | |
30033 | ||
30034 | DEFINITIONS | |
30035 | ||
30036 | AUTOMATIC TAGS | |
30037 | ||
30038 | ::= | |
30039 | ||
30040 | BEGIN | |
30041 | ||
30042 | BERPDU ::= SET | |
30043 | { | |
30044 | b BOOLEAN OPTIONAL, | |
30045 | c INTEGER OPTIONAL | |
30046 | } | |
30047 | ||
30048 | ||
30049 | END | |
30050 | ||
30051 | <STATIC> | |
30052 | ||
30053 | import from TempA all; | |
30054 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30055 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30056 | ||
30057 | const BERPDU myValue := {b := true, | |
30058 | c := 5 } | |
30059 | ||
30060 | <TTCN_TC:EXEC> | |
30061 | ||
30062 | ||
30063 | ||
30064 | ||
30065 | if ((enc_DER_PDU(myValue) == '31068001FF810105'O)and(enc_CER_PDU(myValue) == '31808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30066 | ||
30067 | <RESULT> | |
30068 | ||
30069 | Overall verdict: pass | |
30070 | ||
30071 | <END_TC> | |
30072 | ||
30073 | :exmp. | |
30074 | ||
30075 | .*---------------------------------------------------------------------* | |
30076 | :h3.encoding of SET (both elements are used)(different order) AUTOMATIC TAGGING | |
30077 | .*---------------------------------------------------------------------* | |
30078 | :xmp tab=0. | |
30079 | ||
30080 | <TC - encoding of SET (both elements are used)(different order) AUTOMATIC TAGGING> | |
30081 | ||
30082 | <STATIC:ASN> | |
30083 | ||
30084 | TempA | |
30085 | ||
30086 | DEFINITIONS | |
30087 | ||
30088 | AUTOMATIC TAGS | |
30089 | ||
30090 | ::= | |
30091 | ||
30092 | BEGIN | |
30093 | ||
30094 | BERPDU ::= SET | |
30095 | { | |
30096 | b BOOLEAN OPTIONAL, | |
30097 | c INTEGER OPTIONAL | |
30098 | } | |
30099 | ||
30100 | ||
30101 | END | |
30102 | ||
30103 | <STATIC> | |
30104 | ||
30105 | import from TempA all; | |
30106 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30107 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30108 | ||
30109 | const BERPDU myValue := { | |
30110 | c := 5, | |
30111 | b := true } | |
30112 | ||
30113 | <TTCN_TC:EXEC> | |
30114 | ||
30115 | ||
30116 | ||
30117 | ||
30118 | if ((enc_DER_PDU(myValue) == '31068001FF810105'O)and(enc_CER_PDU(myValue) == '31808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30119 | ||
30120 | <RESULT> | |
30121 | ||
30122 | Overall verdict: pass | |
30123 | ||
30124 | <END_TC> | |
30125 | ||
30126 | :exmp. | |
30127 | ||
30128 | .*---------------------------------------------------------------------* | |
30129 | :h3.CER + DER encoding of SET (both elements are used)(different order2) AUTOMATIC TAGGING | |
30130 | .*---------------------------------------------------------------------* | |
30131 | :xmp tab=0. | |
30132 | ||
30133 | <TC - CER + DER encoding of SET (both elements are used)(different order2) AUTOMATIC TAGGING> | |
30134 | ||
30135 | <STATIC:ASN> | |
30136 | ||
30137 | TempA | |
30138 | ||
30139 | DEFINITIONS | |
30140 | ||
30141 | AUTOMATIC TAGS | |
30142 | ||
30143 | ::= | |
30144 | ||
30145 | BEGIN | |
30146 | ||
30147 | BERPDU ::= SET | |
30148 | { | |
30149 | ||
30150 | c INTEGER OPTIONAL, | |
30151 | b BOOLEAN OPTIONAL | |
30152 | } | |
30153 | ||
30154 | ||
30155 | END | |
30156 | ||
30157 | <STATIC> | |
30158 | ||
30159 | import from TempA all; | |
30160 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30161 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30162 | ||
30163 | const BERPDU myValue := {b := true, | |
30164 | c := 5 } | |
30165 | ||
30166 | <TTCN_TC:EXEC> | |
30167 | ||
30168 | ||
30169 | ||
30170 | ||
30171 | if ((enc_DER_PDU(myValue) == '31068001058101FF'O)and(enc_CER_PDU(myValue) == '31808001058101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30172 | ||
30173 | <RESULT> | |
30174 | ||
30175 | Overall verdict: pass | |
30176 | ||
30177 | <END_TC> | |
30178 | ||
30179 | :exmp. | |
30180 | ||
30181 | .*---------------------------------------------------------------------* | |
30182 | :h3.CER + DER encoding of SET (one element is equal to Default) AUTOMATIC TAGGING | |
30183 | .*---------------------------------------------------------------------* | |
30184 | :xmp tab=0. | |
30185 | ||
30186 | <TC - CER + DER encoding of SET (one element is equal to Default) AUTOMATIC TAGGING> | |
30187 | ||
30188 | <STATIC:ASN> | |
30189 | ||
30190 | TempA | |
30191 | ||
30192 | DEFINITIONS | |
30193 | ||
30194 | AUTOMATIC TAGS | |
30195 | ||
30196 | ::= | |
30197 | ||
30198 | BEGIN | |
30199 | ||
30200 | BERPDU ::= SET | |
30201 | { | |
30202 | b BOOLEAN DEFAULT TRUE, | |
30203 | c INTEGER OPTIONAL | |
30204 | } | |
30205 | ||
30206 | ||
30207 | END | |
30208 | ||
30209 | <STATIC> | |
30210 | ||
30211 | import from TempA all; | |
30212 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30213 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30214 | ||
30215 | const BERPDU myValue := {b := true, | |
30216 | c := 5 } | |
30217 | ||
30218 | <TTCN_TC:EXEC> | |
30219 | ||
30220 | ||
30221 | ||
30222 | ||
30223 | if ((enc_DER_PDU(myValue) == '3103810105'O)and(enc_CER_PDU(myValue) == '31808101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30224 | ||
30225 | <RESULT> | |
30226 | ||
30227 | Overall verdict: pass | |
30228 | ||
30229 | <END_TC> | |
30230 | ||
30231 | :exmp. | |
30232 | ||
30233 | .*---------------------------------------------------------------------* | |
30234 | :h3. encoding of SET (different order) (one element is equal to Default) AUTOMATIC TAGGING | |
30235 | .*---------------------------------------------------------------------* | |
30236 | :xmp tab=0. | |
30237 | ||
30238 | <TC - encoding of SET (different order) (one element is equal to Default) AUTOMATIC TAGGING> | |
30239 | ||
30240 | <STATIC:ASN> | |
30241 | ||
30242 | TempA | |
30243 | ||
30244 | DEFINITIONS | |
30245 | ||
30246 | AUTOMATIC TAGS | |
30247 | ||
30248 | ::= | |
30249 | ||
30250 | BEGIN | |
30251 | ||
30252 | BERPDU ::= SET | |
30253 | { | |
30254 | b BOOLEAN DEFAULT TRUE, | |
30255 | c INTEGER OPTIONAL | |
30256 | } | |
30257 | ||
30258 | ||
30259 | END | |
30260 | ||
30261 | <STATIC> | |
30262 | ||
30263 | import from TempA all; | |
30264 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30265 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30266 | ||
30267 | const BERPDU myValue := { | |
30268 | c := 5 , | |
30269 | b := true } | |
30270 | ||
30271 | <TTCN_TC:EXEC> | |
30272 | ||
30273 | ||
30274 | ||
30275 | ||
30276 | if ((enc_DER_PDU(myValue) == '3103810105'O)and(enc_CER_PDU(myValue) == '31808101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30277 | ||
30278 | <RESULT> | |
30279 | ||
30280 | Overall verdict: pass | |
30281 | ||
30282 | <END_TC> | |
30283 | ||
30284 | :exmp. | |
30285 | ||
30286 | .*---------------------------------------------------------------------* | |
30287 | :h3.CER + DER encoding of SET (one element is not equal to Default) AUTOMATIC TAGGING | |
30288 | .*---------------------------------------------------------------------* | |
30289 | :xmp tab=0. | |
30290 | ||
30291 | <TC - CER + DER encoding of SET (one element is not equal to Default) AUTOMATIC TAGGING> | |
30292 | ||
30293 | <STATIC:ASN> | |
30294 | ||
30295 | TempA | |
30296 | ||
30297 | DEFINITIONS | |
30298 | ||
30299 | AUTOMATIC TAGS | |
30300 | ||
30301 | ::= | |
30302 | ||
30303 | BEGIN | |
30304 | ||
30305 | BERPDU ::= SET | |
30306 | { | |
30307 | b BOOLEAN DEFAULT TRUE, | |
30308 | c INTEGER OPTIONAL | |
30309 | } | |
30310 | ||
30311 | ||
30312 | END | |
30313 | ||
30314 | <STATIC> | |
30315 | ||
30316 | import from TempA all; | |
30317 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30318 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30319 | ||
30320 | const BERPDU myValue := {b := false, | |
30321 | c := 5 } | |
30322 | ||
30323 | <TTCN_TC:EXEC> | |
30324 | ||
30325 | ||
30326 | ||
30327 | ||
30328 | if ((enc_DER_PDU(myValue) == '3106800100810105'O)and(enc_CER_PDU(myValue) == '31808001008101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30329 | ||
30330 | <RESULT> | |
30331 | ||
30332 | Overall verdict: pass | |
30333 | ||
30334 | <END_TC> | |
30335 | ||
30336 | :exmp. | |
30337 | ||
30338 | .*---------------------------------------------------------------------* | |
30339 | :h3. encoding of SET (different order)(one element is not equal to Default) AUTOMATIC TAGGING | |
30340 | .*---------------------------------------------------------------------* | |
30341 | :xmp tab=0. | |
30342 | ||
30343 | <TC - encoding of SET (different order)(one element is not equal to Default) AUTOMATIC TAGGING> | |
30344 | ||
30345 | <STATIC:ASN> | |
30346 | ||
30347 | TempA | |
30348 | ||
30349 | DEFINITIONS | |
30350 | ||
30351 | AUTOMATIC TAGS | |
30352 | ||
30353 | ::= | |
30354 | ||
30355 | BEGIN | |
30356 | ||
30357 | BERPDU ::= SET | |
30358 | { | |
30359 | b BOOLEAN DEFAULT TRUE, | |
30360 | c INTEGER OPTIONAL | |
30361 | } | |
30362 | ||
30363 | ||
30364 | END | |
30365 | ||
30366 | <STATIC> | |
30367 | ||
30368 | import from TempA all; | |
30369 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30370 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30371 | ||
30372 | const BERPDU myValue := { | |
30373 | c := 5, | |
30374 | b := false } | |
30375 | ||
30376 | <TTCN_TC:EXEC> | |
30377 | ||
30378 | ||
30379 | ||
30380 | ||
30381 | if ((enc_DER_PDU(myValue) == '3106800100810105'O)and(enc_CER_PDU(myValue) == '31808001008101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30382 | ||
30383 | <RESULT> | |
30384 | ||
30385 | Overall verdict: pass | |
30386 | ||
30387 | <END_TC> | |
30388 | ||
30389 | :exmp. | |
30390 | ||
30391 | .*---------------------------------------------------------------------* | |
30392 | :h3.CER + DER encoding of SET (different order2)(one element is not equal to Default) AUTOMATIC TAGGING | |
30393 | .*---------------------------------------------------------------------* | |
30394 | :xmp tab=0. | |
30395 | ||
30396 | <TC - CER + DER encoding of SET (different order2)(one element is not equal to Default) AUTOMATIC TAGGING> | |
30397 | ||
30398 | <STATIC:ASN> | |
30399 | ||
30400 | TempA | |
30401 | ||
30402 | DEFINITIONS | |
30403 | ||
30404 | AUTOMATIC TAGS | |
30405 | ||
30406 | ::= | |
30407 | ||
30408 | BEGIN | |
30409 | ||
30410 | BERPDU ::= SET | |
30411 | { | |
30412 | ||
30413 | c INTEGER OPTIONAL, | |
30414 | b BOOLEAN DEFAULT TRUE | |
30415 | } | |
30416 | ||
30417 | ||
30418 | END | |
30419 | ||
30420 | <STATIC> | |
30421 | ||
30422 | import from TempA all; | |
30423 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30424 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30425 | ||
30426 | const BERPDU myValue := {b := false, | |
30427 | c := 5 } | |
30428 | ||
30429 | <TTCN_TC:EXEC> | |
30430 | ||
30431 | ||
30432 | ||
30433 | ||
30434 | if ((enc_DER_PDU(myValue) == '3106800105810100'O)and(enc_CER_PDU(myValue) == '31808001058101000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30435 | ||
30436 | <RESULT> | |
30437 | ||
30438 | Overall verdict: pass | |
30439 | ||
30440 | <END_TC> | |
30441 | ||
30442 | :exmp. | |
30443 | ||
30444 | .*---------------------------------------------------------------------* | |
30445 | :h3.CER + DER encoding of SET (both elements are used) IMPLICIT TAGS for elements | |
30446 | .*---------------------------------------------------------------------* | |
30447 | :xmp tab=0. | |
30448 | ||
30449 | <TC - CER + DER encoding of SET (both elements are used) IMPLICIT TAGS for elements> | |
30450 | ||
30451 | <STATIC:ASN> | |
30452 | ||
30453 | TempA | |
30454 | ||
30455 | DEFINITIONS ::= | |
30456 | BEGIN | |
30457 | ||
30458 | BERPDU ::= SET | |
30459 | { | |
30460 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
30461 | c [31] IMPLICIT INTEGER OPTIONAL | |
30462 | } | |
30463 | ||
30464 | ||
30465 | END | |
30466 | ||
30467 | <STATIC> | |
30468 | ||
30469 | import from TempA all; | |
30470 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30471 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30472 | ||
30473 | const BERPDU myValue := {b := true, | |
30474 | c := 5 } | |
30475 | ||
30476 | <TTCN_TC:EXEC> | |
30477 | ||
30478 | ||
30479 | ||
30480 | ||
30481 | if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30482 | ||
30483 | <RESULT> | |
30484 | ||
30485 | Overall verdict: pass | |
30486 | ||
30487 | <END_TC> | |
30488 | ||
30489 | :exmp. | |
30490 | ||
30491 | .*---------------------------------------------------------------------* | |
30492 | :h3. encoding of SET (different order) (both elements are used) IMPLICIT TAGS for elements | |
30493 | .*---------------------------------------------------------------------* | |
30494 | :xmp tab=0. | |
30495 | ||
30496 | <TC - encoding of SET (different order) (both elements are used) IMPLICIT TAGS for elements> | |
30497 | ||
30498 | <STATIC:ASN> | |
30499 | ||
30500 | TempA | |
30501 | ||
30502 | DEFINITIONS ::= | |
30503 | BEGIN | |
30504 | ||
30505 | BERPDU ::= SET | |
30506 | { | |
30507 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
30508 | c [31] IMPLICIT INTEGER OPTIONAL | |
30509 | } | |
30510 | ||
30511 | ||
30512 | END | |
30513 | ||
30514 | <STATIC> | |
30515 | ||
30516 | import from TempA all; | |
30517 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30518 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30519 | ||
30520 | const BERPDU myValue := { | |
30521 | c := 5, | |
30522 | b := true } | |
30523 | ||
30524 | <TTCN_TC:EXEC> | |
30525 | ||
30526 | ||
30527 | ||
30528 | ||
30529 | if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30530 | ||
30531 | <RESULT> | |
30532 | ||
30533 | Overall verdict: pass | |
30534 | ||
30535 | <END_TC> | |
30536 | ||
30537 | :exmp. | |
30538 | ||
30539 | .*---------------------------------------------------------------------* | |
30540 | :h3.CER + DER encoding of SET (different order2) (both elements are used) IMPLICIT TAGS for elements | |
30541 | .*---------------------------------------------------------------------* | |
30542 | :xmp tab=0. | |
30543 | ||
30544 | <TC - CER + DER encoding of SET (different order2) (both elements are used) IMPLICIT TAGS for elements> | |
30545 | ||
30546 | <STATIC:ASN> | |
30547 | ||
30548 | TempA | |
30549 | ||
30550 | DEFINITIONS ::= | |
30551 | BEGIN | |
30552 | ||
30553 | BERPDU ::= SET | |
30554 | { | |
30555 | c [31] IMPLICIT INTEGER OPTIONAL, | |
30556 | b [30] IMPLICIT BOOLEAN OPTIONAL | |
30557 | } | |
30558 | ||
30559 | ||
30560 | END | |
30561 | ||
30562 | <STATIC> | |
30563 | ||
30564 | import from TempA all; | |
30565 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30566 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30567 | ||
30568 | const BERPDU myValue := {b := true, | |
30569 | c := 5 } | |
30570 | ||
30571 | <TTCN_TC:EXEC> | |
30572 | ||
30573 | ||
30574 | ||
30575 | ||
30576 | if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30577 | ||
30578 | <RESULT> | |
30579 | ||
30580 | Overall verdict: pass | |
30581 | ||
30582 | <END_TC> | |
30583 | ||
30584 | :exmp. | |
30585 | ||
30586 | .*---------------------------------------------------------------------* | |
30587 | :h3.CER + DER encoding of SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT | |
30588 | .*---------------------------------------------------------------------* | |
30589 | :xmp tab=0. | |
30590 | ||
30591 | <TC - CER + DER encoding of SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT> | |
30592 | ||
30593 | <STATIC:ASN> | |
30594 | ||
30595 | TempA | |
30596 | ||
30597 | DEFINITIONS | |
30598 | ||
30599 | EXPLICIT TAGS | |
30600 | ||
30601 | ::= | |
30602 | ||
30603 | BEGIN | |
30604 | ||
30605 | BERPDU ::= SET | |
30606 | { | |
30607 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
30608 | c [31] IMPLICIT INTEGER OPTIONAL | |
30609 | } | |
30610 | ||
30611 | ||
30612 | END | |
30613 | ||
30614 | <STATIC> | |
30615 | ||
30616 | import from TempA all; | |
30617 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30618 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30619 | ||
30620 | const BERPDU myValue := {b := true, | |
30621 | c := 5 } | |
30622 | ||
30623 | <TTCN_TC:EXEC> | |
30624 | ||
30625 | ||
30626 | ||
30627 | ||
30628 | if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30629 | ||
30630 | <RESULT> | |
30631 | ||
30632 | Overall verdict: pass | |
30633 | ||
30634 | <END_TC> | |
30635 | ||
30636 | :exmp. | |
30637 | ||
30638 | .*---------------------------------------------------------------------* | |
30639 | :h3.encoding of SET (different order) (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT | |
30640 | .*---------------------------------------------------------------------* | |
30641 | :xmp tab=0. | |
30642 | ||
30643 | <TC - encoding of SET (different order) (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT> | |
30644 | ||
30645 | <STATIC:ASN> | |
30646 | ||
30647 | TempA | |
30648 | ||
30649 | DEFINITIONS | |
30650 | ||
30651 | EXPLICIT TAGS | |
30652 | ||
30653 | ::= | |
30654 | ||
30655 | BEGIN | |
30656 | ||
30657 | BERPDU ::= SET | |
30658 | { | |
30659 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
30660 | c [31] IMPLICIT INTEGER OPTIONAL | |
30661 | } | |
30662 | ||
30663 | ||
30664 | END | |
30665 | ||
30666 | <STATIC> | |
30667 | ||
30668 | import from TempA all; | |
30669 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30670 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30671 | ||
30672 | const BERPDU myValue := { | |
30673 | c := 5 , | |
30674 | b := true } | |
30675 | ||
30676 | <TTCN_TC:EXEC> | |
30677 | ||
30678 | ||
30679 | ||
30680 | ||
30681 | if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30682 | ||
30683 | <RESULT> | |
30684 | ||
30685 | Overall verdict: pass | |
30686 | ||
30687 | <END_TC> | |
30688 | ||
30689 | :exmp. | |
30690 | ||
30691 | .*---------------------------------------------------------------------* | |
30692 | :h3.CER + DER encoding of SET (different order2)(both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT | |
30693 | .*---------------------------------------------------------------------* | |
30694 | :xmp tab=0. | |
30695 | ||
30696 | <TC - CER + DER encoding of SET (different order2)(both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT> | |
30697 | ||
30698 | <STATIC:ASN> | |
30699 | ||
30700 | TempA | |
30701 | ||
30702 | DEFINITIONS | |
30703 | ||
30704 | EXPLICIT TAGS | |
30705 | ||
30706 | ::= | |
30707 | ||
30708 | BEGIN | |
30709 | ||
30710 | BERPDU ::= SET | |
30711 | { | |
30712 | c [31] IMPLICIT INTEGER OPTIONAL, | |
30713 | b [30] IMPLICIT BOOLEAN OPTIONAL | |
30714 | ||
30715 | } | |
30716 | ||
30717 | ||
30718 | END | |
30719 | ||
30720 | <STATIC> | |
30721 | ||
30722 | import from TempA all; | |
30723 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30724 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30725 | ||
30726 | const BERPDU myValue := {b := true, | |
30727 | c := 5 } | |
30728 | ||
30729 | <TTCN_TC:EXEC> | |
30730 | ||
30731 | ||
30732 | ||
30733 | ||
30734 | if ((enc_DER_PDU(myValue) == '31079E01FF9F1F0105'O)and(enc_CER_PDU(myValue) == '31809E01FF9F1F01050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30735 | ||
30736 | <RESULT> | |
30737 | ||
30738 | Overall verdict: pass | |
30739 | ||
30740 | <END_TC> | |
30741 | ||
30742 | :exmp. | |
30743 | ||
30744 | .*---------------------------------------------------------------------* | |
30745 | :h3.CER + DER encoding of SET (both elements are used) EXPLICIT TAGS for elements | |
30746 | .*---------------------------------------------------------------------* | |
30747 | :xmp tab=0. | |
30748 | ||
30749 | <TC - CER + DER encoding of SET (both elements are used) EXPLICIT TAGS for elements> | |
30750 | ||
30751 | <STATIC:ASN> | |
30752 | ||
30753 | TempA | |
30754 | ||
30755 | DEFINITIONS ::= | |
30756 | BEGIN | |
30757 | ||
30758 | BERPDU ::= SET | |
30759 | { | |
30760 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
30761 | c [31] EXPLICIT INTEGER OPTIONAL | |
30762 | } | |
30763 | ||
30764 | ||
30765 | END | |
30766 | ||
30767 | <STATIC> | |
30768 | ||
30769 | import from TempA all; | |
30770 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30771 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30772 | ||
30773 | const BERPDU myValue := {b := true, | |
30774 | c := 5 } | |
30775 | ||
30776 | <TTCN_TC:EXEC> | |
30777 | ||
30778 | ||
30779 | ||
30780 | ||
30781 | if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30782 | ||
30783 | <RESULT> | |
30784 | ||
30785 | Overall verdict: pass | |
30786 | ||
30787 | <END_TC> | |
30788 | ||
30789 | :exmp. | |
30790 | ||
30791 | .*---------------------------------------------------------------------* | |
30792 | :h3. encoding of SET (different order)(both elements are used) EXPLICIT TAGS for elements | |
30793 | .*---------------------------------------------------------------------* | |
30794 | :xmp tab=0. | |
30795 | ||
30796 | <TC - encoding of SET (different order)(both elements are used) EXPLICIT TAGS for elements> | |
30797 | ||
30798 | <STATIC:ASN> | |
30799 | ||
30800 | TempA | |
30801 | ||
30802 | DEFINITIONS ::= | |
30803 | BEGIN | |
30804 | ||
30805 | BERPDU ::= SET | |
30806 | { | |
30807 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
30808 | c [31] EXPLICIT INTEGER OPTIONAL | |
30809 | } | |
30810 | ||
30811 | ||
30812 | END | |
30813 | ||
30814 | <STATIC> | |
30815 | ||
30816 | import from TempA all; | |
30817 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30818 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30819 | ||
30820 | const BERPDU myValue := { | |
30821 | c := 5, | |
30822 | b := true } | |
30823 | ||
30824 | <TTCN_TC:EXEC> | |
30825 | ||
30826 | ||
30827 | ||
30828 | ||
30829 | if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30830 | ||
30831 | <RESULT> | |
30832 | ||
30833 | Overall verdict: pass | |
30834 | ||
30835 | <END_TC> | |
30836 | ||
30837 | :exmp. | |
30838 | ||
30839 | .*---------------------------------------------------------------------* | |
30840 | :h3.CER + DER encoding of SET (different order2) (both elements are used) EXPLICIT TAGS for elements | |
30841 | .*---------------------------------------------------------------------* | |
30842 | :xmp tab=0. | |
30843 | ||
30844 | <TC - CER + DER encoding of SET (different order2) (both elements are used) EXPLICIT TAGS for elements> | |
30845 | ||
30846 | <STATIC:ASN> | |
30847 | ||
30848 | TempA | |
30849 | ||
30850 | DEFINITIONS ::= | |
30851 | BEGIN | |
30852 | ||
30853 | BERPDU ::= SET | |
30854 | { | |
30855 | ||
30856 | c [31] EXPLICIT INTEGER OPTIONAL, | |
30857 | b [30] EXPLICIT BOOLEAN OPTIONAL | |
30858 | } | |
30859 | ||
30860 | ||
30861 | END | |
30862 | ||
30863 | <STATIC> | |
30864 | ||
30865 | import from TempA all; | |
30866 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30867 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30868 | ||
30869 | const BERPDU myValue := {b := true, | |
30870 | c := 5 } | |
30871 | ||
30872 | <TTCN_TC:EXEC> | |
30873 | ||
30874 | ||
30875 | ||
30876 | ||
30877 | if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30878 | ||
30879 | <RESULT> | |
30880 | ||
30881 | Overall verdict: pass | |
30882 | ||
30883 | <END_TC> | |
30884 | ||
30885 | :exmp. | |
30886 | ||
30887 | .*---------------------------------------------------------------------* | |
30888 | :h3.CER + DER encoding of SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT | |
30889 | .*---------------------------------------------------------------------* | |
30890 | :xmp tab=0. | |
30891 | ||
30892 | <TC - CER + DER encoding of SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT> | |
30893 | ||
30894 | <STATIC:ASN> | |
30895 | ||
30896 | TempA | |
30897 | ||
30898 | DEFINITIONS | |
30899 | ||
30900 | IMPLICIT TAGS | |
30901 | ||
30902 | ::= | |
30903 | ||
30904 | BEGIN | |
30905 | ||
30906 | BERPDU ::= SET | |
30907 | { | |
30908 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
30909 | c [31] EXPLICIT INTEGER OPTIONAL | |
30910 | } | |
30911 | ||
30912 | ||
30913 | END | |
30914 | ||
30915 | <STATIC> | |
30916 | ||
30917 | import from TempA all; | |
30918 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30919 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30920 | ||
30921 | const BERPDU myValue := {b := true, | |
30922 | c := 5 } | |
30923 | ||
30924 | <TTCN_TC:EXEC> | |
30925 | ||
30926 | ||
30927 | ||
30928 | ||
30929 | if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30930 | ||
30931 | <RESULT> | |
30932 | ||
30933 | Overall verdict: pass | |
30934 | ||
30935 | <END_TC> | |
30936 | ||
30937 | :exmp. | |
30938 | ||
30939 | .*---------------------------------------------------------------------* | |
30940 | :h3. encoding of SET (different order) (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT | |
30941 | .*---------------------------------------------------------------------* | |
30942 | :xmp tab=0. | |
30943 | ||
30944 | <TC - encoding of SET (different order) (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT> | |
30945 | ||
30946 | <STATIC:ASN> | |
30947 | ||
30948 | TempA | |
30949 | ||
30950 | DEFINITIONS | |
30951 | ||
30952 | IMPLICIT TAGS | |
30953 | ||
30954 | ::= | |
30955 | ||
30956 | BEGIN | |
30957 | ||
30958 | BERPDU ::= SET | |
30959 | { | |
30960 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
30961 | c [31] EXPLICIT INTEGER OPTIONAL | |
30962 | } | |
30963 | ||
30964 | ||
30965 | END | |
30966 | ||
30967 | <STATIC> | |
30968 | ||
30969 | import from TempA all; | |
30970 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
30971 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
30972 | ||
30973 | const BERPDU myValue := { | |
30974 | c := 5 , | |
30975 | b := true } | |
30976 | ||
30977 | <TTCN_TC:EXEC> | |
30978 | ||
30979 | ||
30980 | ||
30981 | ||
30982 | if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
30983 | ||
30984 | <RESULT> | |
30985 | ||
30986 | Overall verdict: pass | |
30987 | ||
30988 | <END_TC> | |
30989 | ||
30990 | :exmp. | |
30991 | ||
30992 | .*---------------------------------------------------------------------* | |
30993 | :h3.CER + DER encoding of SET (different order2)(both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT | |
30994 | .*---------------------------------------------------------------------* | |
30995 | :xmp tab=0. | |
30996 | ||
30997 | <TC - CER + DER encoding of SET (different order2)(both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT> | |
30998 | ||
30999 | <STATIC:ASN> | |
31000 | ||
31001 | TempA | |
31002 | ||
31003 | DEFINITIONS | |
31004 | ||
31005 | IMPLICIT TAGS | |
31006 | ||
31007 | ::= | |
31008 | ||
31009 | BEGIN | |
31010 | ||
31011 | BERPDU ::= SET | |
31012 | { | |
31013 | c [31] EXPLICIT INTEGER OPTIONAL, | |
31014 | b [30] EXPLICIT BOOLEAN OPTIONAL | |
31015 | ||
31016 | } | |
31017 | ||
31018 | ||
31019 | END | |
31020 | ||
31021 | <STATIC> | |
31022 | ||
31023 | import from TempA all; | |
31024 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31025 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31026 | ||
31027 | const BERPDU myValue := {b := true, | |
31028 | c := 5 } | |
31029 | ||
31030 | <TTCN_TC:EXEC> | |
31031 | ||
31032 | ||
31033 | ||
31034 | ||
31035 | if ((enc_DER_PDU(myValue) == '310BBE030101FFBF1F03020105'O)and(enc_CER_PDU(myValue) == '3180BE800101FF0000BF1F8002010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31036 | ||
31037 | <RESULT> | |
31038 | ||
31039 | Overall verdict: pass | |
31040 | ||
31041 | <END_TC> | |
31042 | ||
31043 | :exmp. | |
31044 | ||
31045 | .*---------------------------------------------------------------------* | |
31046 | :h3.CER + DER encoding of TAGGED SET (both elements are used) | |
31047 | .*---------------------------------------------------------------------* | |
31048 | :xmp tab=0. | |
31049 | ||
31050 | <TC - CER + DER encoding of TAGGED SET (both elements are used)> | |
31051 | ||
31052 | <STATIC:ASN> | |
31053 | ||
31054 | TempA | |
31055 | ||
31056 | DEFINITIONS ::= | |
31057 | BEGIN | |
31058 | ||
31059 | BERPDU ::= [0] SET | |
31060 | { | |
31061 | b BOOLEAN OPTIONAL, | |
31062 | c INTEGER OPTIONAL | |
31063 | } | |
31064 | ||
31065 | ||
31066 | END | |
31067 | ||
31068 | <STATIC> | |
31069 | ||
31070 | import from TempA all; | |
31071 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31072 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31073 | ||
31074 | const BERPDU myValue := {b := true, | |
31075 | c := 5 } | |
31076 | ||
31077 | <TTCN_TC:EXEC> | |
31078 | ||
31079 | ||
31080 | ||
31081 | ||
31082 | if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31083 | ||
31084 | <RESULT> | |
31085 | ||
31086 | Overall verdict: pass | |
31087 | ||
31088 | <END_TC> | |
31089 | ||
31090 | :exmp. | |
31091 | ||
31092 | .*---------------------------------------------------------------------* | |
31093 | :h3. encoding of TAGGED SET (different order) (both elements are used) | |
31094 | .*---------------------------------------------------------------------* | |
31095 | :xmp tab=0. | |
31096 | ||
31097 | <TC - encoding of TAGGED SET (different order) (both elements are used)> | |
31098 | ||
31099 | <STATIC:ASN> | |
31100 | ||
31101 | TempA | |
31102 | ||
31103 | DEFINITIONS ::= | |
31104 | BEGIN | |
31105 | ||
31106 | BERPDU ::= [0] SET | |
31107 | { | |
31108 | b BOOLEAN OPTIONAL, | |
31109 | c INTEGER OPTIONAL | |
31110 | } | |
31111 | ||
31112 | ||
31113 | END | |
31114 | ||
31115 | <STATIC> | |
31116 | ||
31117 | import from TempA all; | |
31118 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31119 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31120 | ||
31121 | const BERPDU myValue := { | |
31122 | c := 5, | |
31123 | b := true } | |
31124 | ||
31125 | <TTCN_TC:EXEC> | |
31126 | ||
31127 | ||
31128 | ||
31129 | ||
31130 | if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31131 | ||
31132 | <RESULT> | |
31133 | ||
31134 | Overall verdict: pass | |
31135 | ||
31136 | <END_TC> | |
31137 | ||
31138 | :exmp. | |
31139 | ||
31140 | .*---------------------------------------------------------------------* | |
31141 | :h3.CER + DER encoding of TAGGED SET (different order2) (both elements are used) | |
31142 | .*---------------------------------------------------------------------* | |
31143 | :xmp tab=0. | |
31144 | ||
31145 | <TC - CER + DER encoding of TAGGED SET (different order2) (both elements are used)> | |
31146 | ||
31147 | <STATIC:ASN> | |
31148 | ||
31149 | TempA | |
31150 | ||
31151 | DEFINITIONS ::= | |
31152 | BEGIN | |
31153 | ||
31154 | BERPDU ::= [0] SET | |
31155 | { | |
31156 | ||
31157 | c INTEGER OPTIONAL, | |
31158 | b BOOLEAN OPTIONAL | |
31159 | } | |
31160 | ||
31161 | ||
31162 | END | |
31163 | ||
31164 | <STATIC> | |
31165 | ||
31166 | import from TempA all; | |
31167 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31168 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31169 | ||
31170 | const BERPDU myValue := {b := true, | |
31171 | c := 5 } | |
31172 | ||
31173 | <TTCN_TC:EXEC> | |
31174 | ||
31175 | ||
31176 | ||
31177 | ||
31178 | if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31179 | ||
31180 | <RESULT> | |
31181 | ||
31182 | Overall verdict: pass | |
31183 | ||
31184 | <END_TC> | |
31185 | ||
31186 | :exmp. | |
31187 | ||
31188 | .*---------------------------------------------------------------------* | |
31189 | :h3.CER + DER encoding of TAGGED SET (both elements are used), AUTOMATIC TAGGING ENVIRONMENT | |
31190 | .*---------------------------------------------------------------------* | |
31191 | :xmp tab=0. | |
31192 | ||
31193 | <TC - CER + DER encoding of TAGGED SET (both elements are used), AUTOMATIC TAGGING ENVIRONMENT> | |
31194 | ||
31195 | <STATIC:ASN> | |
31196 | ||
31197 | TempA | |
31198 | ||
31199 | DEFINITIONS | |
31200 | ||
31201 | AUTOMATIC TAGS | |
31202 | ||
31203 | ::= | |
31204 | ||
31205 | BEGIN | |
31206 | ||
31207 | BERPDU ::= [0] SET | |
31208 | { | |
31209 | b BOOLEAN OPTIONAL, | |
31210 | c INTEGER OPTIONAL | |
31211 | } | |
31212 | ||
31213 | ||
31214 | END | |
31215 | ||
31216 | <STATIC> | |
31217 | ||
31218 | import from TempA all; | |
31219 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31220 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31221 | ||
31222 | const BERPDU myValue := {b := true, | |
31223 | c := 5 } | |
31224 | ||
31225 | <TTCN_TC:EXEC> | |
31226 | ||
31227 | ||
31228 | ||
31229 | ||
31230 | if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31231 | ||
31232 | <RESULT> | |
31233 | ||
31234 | Overall verdict: pass | |
31235 | ||
31236 | <END_TC> | |
31237 | ||
31238 | :exmp. | |
31239 | ||
31240 | .*---------------------------------------------------------------------* | |
31241 | :h3. encoding of TAGGED SET (different order) (both elements are used), AUTOMATIC TAGGING ENVIRONMENT | |
31242 | .*---------------------------------------------------------------------* | |
31243 | :xmp tab=0. | |
31244 | ||
31245 | <TC - encoding of TAGGED SET (different order) (both elements are used), AUTOMATIC TAGGING ENVIRONMENT> | |
31246 | ||
31247 | <STATIC:ASN> | |
31248 | ||
31249 | TempA | |
31250 | ||
31251 | DEFINITIONS | |
31252 | ||
31253 | AUTOMATIC TAGS | |
31254 | ||
31255 | ::= | |
31256 | ||
31257 | BEGIN | |
31258 | ||
31259 | BERPDU ::= [0] SET | |
31260 | { | |
31261 | b BOOLEAN OPTIONAL, | |
31262 | c INTEGER OPTIONAL | |
31263 | } | |
31264 | ||
31265 | ||
31266 | END | |
31267 | ||
31268 | <STATIC> | |
31269 | ||
31270 | import from TempA all; | |
31271 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31272 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31273 | ||
31274 | const BERPDU myValue := { | |
31275 | c := 5, | |
31276 | b := true } | |
31277 | ||
31278 | <TTCN_TC:EXEC> | |
31279 | ||
31280 | ||
31281 | ||
31282 | ||
31283 | if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31284 | ||
31285 | <RESULT> | |
31286 | ||
31287 | Overall verdict: pass | |
31288 | ||
31289 | <END_TC> | |
31290 | ||
31291 | :exmp. | |
31292 | ||
31293 | .*---------------------------------------------------------------------* | |
31294 | :h3.CER + DER encoding of TAGGED SET (different order2) (both elements are used), AUTOMATIC TAGGING ENVIRONMENT | |
31295 | .*---------------------------------------------------------------------* | |
31296 | :xmp tab=0. | |
31297 | ||
31298 | <TC - CER + DER encoding of TAGGED SET (different order2) (both elements are used), AUTOMATIC TAGGING ENVIRONMENT> | |
31299 | ||
31300 | <STATIC:ASN> | |
31301 | ||
31302 | TempA | |
31303 | ||
31304 | DEFINITIONS | |
31305 | ||
31306 | AUTOMATIC TAGS | |
31307 | ||
31308 | ::= | |
31309 | ||
31310 | BEGIN | |
31311 | ||
31312 | BERPDU ::= [0] SET | |
31313 | { | |
31314 | c INTEGER OPTIONAL, | |
31315 | b BOOLEAN OPTIONAL | |
31316 | } | |
31317 | ||
31318 | ||
31319 | END | |
31320 | ||
31321 | <STATIC> | |
31322 | ||
31323 | import from TempA all; | |
31324 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31325 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31326 | ||
31327 | const BERPDU myValue := {b := true, | |
31328 | c := 5 } | |
31329 | ||
31330 | <TTCN_TC:EXEC> | |
31331 | ||
31332 | ||
31333 | ||
31334 | ||
31335 | if ((enc_DER_PDU(myValue) == 'A0068001058101FF'O)and(enc_CER_PDU(myValue) == 'A0808001058101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31336 | ||
31337 | <RESULT> | |
31338 | ||
31339 | Overall verdict: pass | |
31340 | ||
31341 | <END_TC> | |
31342 | ||
31343 | :exmp. | |
31344 | ||
31345 | .*---------------------------------------------------------------------* | |
31346 | :h3.CER + DER encoding of TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT | |
31347 | .*---------------------------------------------------------------------* | |
31348 | :xmp tab=0. | |
31349 | ||
31350 | <TC - CER + DER encoding of TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT> | |
31351 | ||
31352 | <STATIC:ASN> | |
31353 | ||
31354 | TempA | |
31355 | ||
31356 | DEFINITIONS | |
31357 | ||
31358 | IMPLICIT TAGS | |
31359 | ||
31360 | ::= | |
31361 | ||
31362 | BEGIN | |
31363 | ||
31364 | BERPDU ::= [0] SET | |
31365 | { | |
31366 | b BOOLEAN OPTIONAL, | |
31367 | c INTEGER OPTIONAL | |
31368 | } | |
31369 | ||
31370 | ||
31371 | END | |
31372 | ||
31373 | <STATIC> | |
31374 | ||
31375 | import from TempA all; | |
31376 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31377 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31378 | ||
31379 | const BERPDU myValue := {b := true, | |
31380 | c := 5 } | |
31381 | ||
31382 | <TTCN_TC:EXEC> | |
31383 | ||
31384 | ||
31385 | ||
31386 | ||
31387 | if ((enc_DER_PDU(myValue) == 'A0060101FF020105'O)and(enc_CER_PDU(myValue) == 'A0800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31388 | ||
31389 | <RESULT> | |
31390 | ||
31391 | Overall verdict: pass | |
31392 | ||
31393 | <END_TC> | |
31394 | ||
31395 | :exmp. | |
31396 | ||
31397 | .*---------------------------------------------------------------------* | |
31398 | :h3. encoding of TAGGED SET (different order)(both elements are used), IMPLICIT TAGGING ENVIRONMENT | |
31399 | .*---------------------------------------------------------------------* | |
31400 | :xmp tab=0. | |
31401 | ||
31402 | <TC - encoding of TAGGED SET (different order)(both elements are used), IMPLICIT TAGGING ENVIRONMENT> | |
31403 | ||
31404 | <STATIC:ASN> | |
31405 | ||
31406 | TempA | |
31407 | ||
31408 | DEFINITIONS | |
31409 | ||
31410 | IMPLICIT TAGS | |
31411 | ||
31412 | ::= | |
31413 | ||
31414 | BEGIN | |
31415 | ||
31416 | BERPDU ::= [0] SET | |
31417 | { | |
31418 | b BOOLEAN OPTIONAL, | |
31419 | c INTEGER OPTIONAL | |
31420 | } | |
31421 | ||
31422 | ||
31423 | END | |
31424 | ||
31425 | <STATIC> | |
31426 | ||
31427 | import from TempA all; | |
31428 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31429 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31430 | ||
31431 | const BERPDU myValue := { | |
31432 | c := 5, | |
31433 | b := true } | |
31434 | ||
31435 | <TTCN_TC:EXEC> | |
31436 | ||
31437 | ||
31438 | ||
31439 | ||
31440 | if ((enc_DER_PDU(myValue) == 'A0060101FF020105'O)and(enc_CER_PDU(myValue) == 'A0800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31441 | ||
31442 | <RESULT> | |
31443 | ||
31444 | Overall verdict: pass | |
31445 | ||
31446 | <END_TC> | |
31447 | ||
31448 | :exmp. | |
31449 | ||
31450 | .*---------------------------------------------------------------------* | |
31451 | :h3.CER + DER encoding of TAGGED SET (different order2)(both elements are used), IMPLICIT TAGGING ENVIRONMENT | |
31452 | .*---------------------------------------------------------------------* | |
31453 | :xmp tab=0. | |
31454 | ||
31455 | <TC - CER + DER encoding of TAGGED SET (different order2)(both elements are used), IMPLICIT TAGGING ENVIRONMENT> | |
31456 | ||
31457 | <STATIC:ASN> | |
31458 | ||
31459 | TempA | |
31460 | ||
31461 | DEFINITIONS | |
31462 | ||
31463 | IMPLICIT TAGS | |
31464 | ||
31465 | ::= | |
31466 | ||
31467 | BEGIN | |
31468 | ||
31469 | BERPDU ::= [0] SET | |
31470 | { | |
31471 | ||
31472 | c INTEGER OPTIONAL, | |
31473 | b BOOLEAN OPTIONAL | |
31474 | } | |
31475 | ||
31476 | ||
31477 | END | |
31478 | ||
31479 | <STATIC> | |
31480 | ||
31481 | import from TempA all; | |
31482 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31483 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31484 | ||
31485 | const BERPDU myValue := {b := true, | |
31486 | c := 5 } | |
31487 | ||
31488 | <TTCN_TC:EXEC> | |
31489 | ||
31490 | ||
31491 | ||
31492 | ||
31493 | if ((enc_DER_PDU(myValue) == 'A0060101FF020105'O)and(enc_CER_PDU(myValue) == 'A0800101FF0201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31494 | ||
31495 | <RESULT> | |
31496 | ||
31497 | Overall verdict: pass | |
31498 | ||
31499 | <END_TC> | |
31500 | ||
31501 | :exmp. | |
31502 | ||
31503 | .*---------------------------------------------------------------------* | |
31504 | :h3.CER + DER encoding of TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT | |
31505 | .*---------------------------------------------------------------------* | |
31506 | :xmp tab=0. | |
31507 | ||
31508 | <TC - CER + DER encoding of TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT> | |
31509 | ||
31510 | <STATIC:ASN> | |
31511 | ||
31512 | TempA | |
31513 | ||
31514 | DEFINITIONS | |
31515 | ||
31516 | EXPLICIT TAGS | |
31517 | ||
31518 | ::= | |
31519 | ||
31520 | BEGIN | |
31521 | ||
31522 | BERPDU ::= [0] SET | |
31523 | { | |
31524 | b BOOLEAN OPTIONAL, | |
31525 | c INTEGER OPTIONAL | |
31526 | } | |
31527 | ||
31528 | ||
31529 | END | |
31530 | ||
31531 | <STATIC> | |
31532 | ||
31533 | import from TempA all; | |
31534 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31535 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31536 | ||
31537 | const BERPDU myValue := {b := true, | |
31538 | c := 5 } | |
31539 | ||
31540 | <TTCN_TC:EXEC> | |
31541 | ||
31542 | ||
31543 | ||
31544 | ||
31545 | if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31546 | ||
31547 | <RESULT> | |
31548 | ||
31549 | Overall verdict: pass | |
31550 | ||
31551 | <END_TC> | |
31552 | ||
31553 | :exmp. | |
31554 | ||
31555 | .*---------------------------------------------------------------------* | |
31556 | :h3. encoding of TAGGED SET (different order) (both elements are used), EXPLICIT TAGGING ENVIRONMENT | |
31557 | .*---------------------------------------------------------------------* | |
31558 | :xmp tab=0. | |
31559 | ||
31560 | <TC - encoding of TAGGED SET (different order) (both elements are used), EXPLICIT TAGGING ENVIRONMENT> | |
31561 | ||
31562 | <STATIC:ASN> | |
31563 | ||
31564 | TempA | |
31565 | ||
31566 | DEFINITIONS | |
31567 | ||
31568 | EXPLICIT TAGS | |
31569 | ||
31570 | ::= | |
31571 | ||
31572 | BEGIN | |
31573 | ||
31574 | BERPDU ::= [0] SET | |
31575 | { | |
31576 | b BOOLEAN OPTIONAL, | |
31577 | c INTEGER OPTIONAL | |
31578 | } | |
31579 | ||
31580 | ||
31581 | END | |
31582 | ||
31583 | <STATIC> | |
31584 | ||
31585 | import from TempA all; | |
31586 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31587 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31588 | ||
31589 | const BERPDU myValue := { | |
31590 | c := 5, | |
31591 | b := true } | |
31592 | ||
31593 | <TTCN_TC:EXEC> | |
31594 | ||
31595 | ||
31596 | ||
31597 | ||
31598 | if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31599 | ||
31600 | <RESULT> | |
31601 | ||
31602 | Overall verdict: pass | |
31603 | ||
31604 | <END_TC> | |
31605 | ||
31606 | :exmp. | |
31607 | ||
31608 | .*---------------------------------------------------------------------* | |
31609 | :h3.CER + DER encoding of TAGGED SET (different order2) (both elements are used), EXPLICIT TAGGING ENVIRONMENT | |
31610 | .*---------------------------------------------------------------------* | |
31611 | :xmp tab=0. | |
31612 | ||
31613 | <TC - CER + DER encoding of TAGGED SET (different order2) (both elements are used), EXPLICIT TAGGING ENVIRONMENT> | |
31614 | ||
31615 | <STATIC:ASN> | |
31616 | ||
31617 | TempA | |
31618 | ||
31619 | DEFINITIONS | |
31620 | ||
31621 | EXPLICIT TAGS | |
31622 | ||
31623 | ::= | |
31624 | ||
31625 | BEGIN | |
31626 | ||
31627 | BERPDU ::= [0] SET | |
31628 | { | |
31629 | c INTEGER OPTIONAL, | |
31630 | b BOOLEAN OPTIONAL | |
31631 | } | |
31632 | ||
31633 | ||
31634 | END | |
31635 | ||
31636 | <STATIC> | |
31637 | ||
31638 | import from TempA all; | |
31639 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31640 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31641 | ||
31642 | const BERPDU myValue := {b := true, | |
31643 | c := 5 } | |
31644 | ||
31645 | <TTCN_TC:EXEC> | |
31646 | ||
31647 | ||
31648 | ||
31649 | ||
31650 | if ((enc_DER_PDU(myValue) == 'A00831060101FF020105'O)and(enc_CER_PDU(myValue) == 'A08031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31651 | ||
31652 | <RESULT> | |
31653 | ||
31654 | Overall verdict: pass | |
31655 | ||
31656 | <END_TC> | |
31657 | ||
31658 | :exmp. | |
31659 | ||
31660 | .*---------------------------------------------------------------------* | |
31661 | :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used) | |
31662 | .*---------------------------------------------------------------------* | |
31663 | :xmp tab=0. | |
31664 | ||
31665 | <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used)> | |
31666 | ||
31667 | <STATIC:ASN> | |
31668 | ||
31669 | TempA | |
31670 | ||
31671 | DEFINITIONS ::= | |
31672 | BEGIN | |
31673 | ||
31674 | BERPDU ::= [0] SET | |
31675 | { | |
31676 | b [0] BOOLEAN OPTIONAL, | |
31677 | c [1] INTEGER OPTIONAL | |
31678 | } | |
31679 | ||
31680 | ||
31681 | END | |
31682 | ||
31683 | <STATIC> | |
31684 | ||
31685 | import from TempA all; | |
31686 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31687 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31688 | ||
31689 | const BERPDU myValue := {b := true, | |
31690 | c := 5 } | |
31691 | ||
31692 | <TTCN_TC:EXEC> | |
31693 | ||
31694 | ||
31695 | ||
31696 | ||
31697 | if ((enc_DER_PDU(myValue) == 'A00C310AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803180A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31698 | ||
31699 | <RESULT> | |
31700 | ||
31701 | Overall verdict: pass | |
31702 | ||
31703 | <END_TC> | |
31704 | ||
31705 | :exmp. | |
31706 | ||
31707 | .*---------------------------------------------------------------------* | |
31708 | :h3. encoding of TAGGED SET (both elements are TAGGED and used) | |
31709 | .*---------------------------------------------------------------------* | |
31710 | :xmp tab=0. | |
31711 | ||
31712 | <TC - encoding of TAGGED SET (both elements are TAGGED and used)> | |
31713 | ||
31714 | <STATIC:ASN> | |
31715 | ||
31716 | TempA | |
31717 | ||
31718 | DEFINITIONS ::= | |
31719 | BEGIN | |
31720 | ||
31721 | BERPDU ::= [0] SET | |
31722 | { | |
31723 | b [0] BOOLEAN OPTIONAL, | |
31724 | c [1] INTEGER OPTIONAL | |
31725 | } | |
31726 | ||
31727 | ||
31728 | END | |
31729 | ||
31730 | <STATIC> | |
31731 | ||
31732 | import from TempA all; | |
31733 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31734 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31735 | ||
31736 | const BERPDU myValue := { | |
31737 | c := 5, | |
31738 | b := true } | |
31739 | ||
31740 | <TTCN_TC:EXEC> | |
31741 | ||
31742 | ||
31743 | ||
31744 | ||
31745 | if ((enc_DER_PDU(myValue) == 'A00C310AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803180A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31746 | ||
31747 | <RESULT> | |
31748 | ||
31749 | Overall verdict: pass | |
31750 | ||
31751 | <END_TC> | |
31752 | ||
31753 | :exmp. | |
31754 | ||
31755 | .*---------------------------------------------------------------------* | |
31756 | :h3.CER + DER encoding of TAGGED SET (different order) (both elements are TAGGED and used) | |
31757 | .*---------------------------------------------------------------------* | |
31758 | :xmp tab=0. | |
31759 | ||
31760 | <TC - CER + DER encoding of TAGGED SET (different order) (both elements are TAGGED and used)> | |
31761 | ||
31762 | <STATIC:ASN> | |
31763 | ||
31764 | TempA | |
31765 | ||
31766 | DEFINITIONS ::= | |
31767 | BEGIN | |
31768 | ||
31769 | BERPDU ::= [0] SET | |
31770 | { | |
31771 | b [1] BOOLEAN OPTIONAL, | |
31772 | c [0] INTEGER OPTIONAL | |
31773 | } | |
31774 | ||
31775 | ||
31776 | END | |
31777 | ||
31778 | <STATIC> | |
31779 | ||
31780 | import from TempA all; | |
31781 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31782 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31783 | ||
31784 | const BERPDU myValue := {b := true, | |
31785 | c := 5 } | |
31786 | ||
31787 | <TTCN_TC:EXEC> | |
31788 | ||
31789 | ||
31790 | ||
31791 | ||
31792 | if ((enc_DER_PDU(myValue) == 'A00C310AA003020105A1030101FF'O)and(enc_CER_PDU(myValue) == 'A0803180A0800201050000A1800101FF000000000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31793 | ||
31794 | <RESULT> | |
31795 | ||
31796 | Overall verdict: pass | |
31797 | ||
31798 | <END_TC> | |
31799 | ||
31800 | :exmp. | |
31801 | ||
31802 | .*---------------------------------------------------------------------* | |
31803 | :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT | |
31804 | .*---------------------------------------------------------------------* | |
31805 | :xmp tab=0. | |
31806 | ||
31807 | <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT> | |
31808 | ||
31809 | <STATIC:ASN> | |
31810 | ||
31811 | TempA | |
31812 | ||
31813 | DEFINITIONS | |
31814 | ||
31815 | EXPLICIT TAGS | |
31816 | ||
31817 | ::= | |
31818 | ||
31819 | BEGIN | |
31820 | ||
31821 | BERPDU ::= [0] SET | |
31822 | { | |
31823 | b [0] BOOLEAN OPTIONAL, | |
31824 | c [1] INTEGER OPTIONAL | |
31825 | } | |
31826 | ||
31827 | ||
31828 | END | |
31829 | ||
31830 | <STATIC> | |
31831 | ||
31832 | import from TempA all; | |
31833 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31834 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31835 | ||
31836 | const BERPDU myValue := {b := true, | |
31837 | c := 5 } | |
31838 | ||
31839 | <TTCN_TC:EXEC> | |
31840 | ||
31841 | ||
31842 | ||
31843 | ||
31844 | if ((enc_DER_PDU(myValue) == 'A00C310AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803180A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31845 | ||
31846 | <RESULT> | |
31847 | ||
31848 | Overall verdict: pass | |
31849 | ||
31850 | <END_TC> | |
31851 | ||
31852 | :exmp. | |
31853 | ||
31854 | .*---------------------------------------------------------------------* | |
31855 | :h3. encoding of TAGGED SET (different order)(both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT | |
31856 | .*---------------------------------------------------------------------* | |
31857 | :xmp tab=0. | |
31858 | ||
31859 | <TC - encoding of TAGGED SET (different order)(both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT> | |
31860 | ||
31861 | <STATIC:ASN> | |
31862 | ||
31863 | TempA | |
31864 | ||
31865 | DEFINITIONS | |
31866 | ||
31867 | EXPLICIT TAGS | |
31868 | ||
31869 | ::= | |
31870 | ||
31871 | BEGIN | |
31872 | ||
31873 | BERPDU ::= [0] SET | |
31874 | { | |
31875 | b [0] BOOLEAN OPTIONAL, | |
31876 | c [1] INTEGER OPTIONAL | |
31877 | } | |
31878 | ||
31879 | ||
31880 | END | |
31881 | ||
31882 | <STATIC> | |
31883 | ||
31884 | import from TempA all; | |
31885 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31886 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31887 | ||
31888 | const BERPDU myValue := { | |
31889 | c := 5, | |
31890 | b := true } | |
31891 | ||
31892 | <TTCN_TC:EXEC> | |
31893 | ||
31894 | ||
31895 | ||
31896 | ||
31897 | if ((enc_DER_PDU(myValue) == 'A00C310AA0030101FFA103020105'O)and(enc_CER_PDU(myValue) == 'A0803180A0800101FF0000A180020105000000000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31898 | ||
31899 | <RESULT> | |
31900 | ||
31901 | Overall verdict: pass | |
31902 | ||
31903 | <END_TC> | |
31904 | ||
31905 | :exmp. | |
31906 | ||
31907 | .*---------------------------------------------------------------------* | |
31908 | :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT | |
31909 | .*---------------------------------------------------------------------* | |
31910 | :xmp tab=0. | |
31911 | ||
31912 | <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT> | |
31913 | ||
31914 | <STATIC:ASN> | |
31915 | ||
31916 | TempA | |
31917 | ||
31918 | DEFINITIONS | |
31919 | ||
31920 | EXPLICIT TAGS | |
31921 | ||
31922 | ::= | |
31923 | ||
31924 | BEGIN | |
31925 | ||
31926 | BERPDU ::= [0] SET | |
31927 | { | |
31928 | b [1] BOOLEAN OPTIONAL, | |
31929 | c [0] INTEGER OPTIONAL | |
31930 | } | |
31931 | ||
31932 | ||
31933 | END | |
31934 | ||
31935 | <STATIC> | |
31936 | ||
31937 | import from TempA all; | |
31938 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31939 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31940 | ||
31941 | const BERPDU myValue := {b := true, | |
31942 | c := 5 } | |
31943 | ||
31944 | <TTCN_TC:EXEC> | |
31945 | ||
31946 | ||
31947 | ||
31948 | ||
31949 | if ((enc_DER_PDU(myValue) == 'A00C310AA003020105A1030101FF'O)and(enc_CER_PDU(myValue) == 'A0803180A0800201050000A1800101FF000000000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
31950 | ||
31951 | <RESULT> | |
31952 | ||
31953 | Overall verdict: pass | |
31954 | ||
31955 | <END_TC> | |
31956 | ||
31957 | :exmp. | |
31958 | ||
31959 | .*---------------------------------------------------------------------* | |
31960 | :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT | |
31961 | .*---------------------------------------------------------------------* | |
31962 | :xmp tab=0. | |
31963 | ||
31964 | <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT> | |
31965 | ||
31966 | <STATIC:ASN> | |
31967 | ||
31968 | TempA | |
31969 | ||
31970 | DEFINITIONS | |
31971 | ||
31972 | IMPLICIT TAGS | |
31973 | ||
31974 | ::= | |
31975 | ||
31976 | BEGIN | |
31977 | ||
31978 | BERPDU ::= [0] SET | |
31979 | { | |
31980 | b [0] BOOLEAN OPTIONAL, | |
31981 | c [1] INTEGER OPTIONAL | |
31982 | } | |
31983 | ||
31984 | ||
31985 | END | |
31986 | ||
31987 | <STATIC> | |
31988 | ||
31989 | import from TempA all; | |
31990 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
31991 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
31992 | ||
31993 | const BERPDU myValue := {b := true, | |
31994 | c := 5 } | |
31995 | ||
31996 | <TTCN_TC:EXEC> | |
31997 | ||
31998 | ||
31999 | ||
32000 | ||
32001 | if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32002 | ||
32003 | <RESULT> | |
32004 | ||
32005 | Overall verdict: pass | |
32006 | ||
32007 | <END_TC> | |
32008 | ||
32009 | :exmp. | |
32010 | ||
32011 | .*---------------------------------------------------------------------* | |
32012 | :h3. encoding of TAGGED SET (different order) (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT | |
32013 | .*---------------------------------------------------------------------* | |
32014 | :xmp tab=0. | |
32015 | ||
32016 | <TC - encoding of TAGGED SET (different order) (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT> | |
32017 | ||
32018 | <STATIC:ASN> | |
32019 | ||
32020 | TempA | |
32021 | ||
32022 | DEFINITIONS | |
32023 | ||
32024 | IMPLICIT TAGS | |
32025 | ||
32026 | ::= | |
32027 | ||
32028 | BEGIN | |
32029 | ||
32030 | BERPDU ::= [0] SET | |
32031 | { | |
32032 | b [0] BOOLEAN OPTIONAL, | |
32033 | c [1] INTEGER OPTIONAL | |
32034 | } | |
32035 | ||
32036 | ||
32037 | END | |
32038 | ||
32039 | <STATIC> | |
32040 | ||
32041 | import from TempA all; | |
32042 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32043 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32044 | ||
32045 | const BERPDU myValue := { | |
32046 | c := 5, | |
32047 | b := true } | |
32048 | ||
32049 | <TTCN_TC:EXEC> | |
32050 | ||
32051 | ||
32052 | ||
32053 | ||
32054 | if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32055 | ||
32056 | <RESULT> | |
32057 | ||
32058 | Overall verdict: pass | |
32059 | ||
32060 | <END_TC> | |
32061 | ||
32062 | :exmp. | |
32063 | ||
32064 | .*---------------------------------------------------------------------* | |
32065 | :h3.CER + DER encoding of TAGGED SET (different order2)(both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT | |
32066 | .*---------------------------------------------------------------------* | |
32067 | :xmp tab=0. | |
32068 | ||
32069 | <TC - CER + DER encoding of TAGGED SET (different order2)(both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT> | |
32070 | ||
32071 | <STATIC:ASN> | |
32072 | ||
32073 | TempA | |
32074 | ||
32075 | DEFINITIONS | |
32076 | ||
32077 | IMPLICIT TAGS | |
32078 | ||
32079 | ::= | |
32080 | ||
32081 | BEGIN | |
32082 | ||
32083 | BERPDU ::= [0] SET | |
32084 | { | |
32085 | ||
32086 | c [1] INTEGER OPTIONAL, | |
32087 | b [0] BOOLEAN OPTIONAL | |
32088 | } | |
32089 | ||
32090 | ||
32091 | END | |
32092 | ||
32093 | <STATIC> | |
32094 | ||
32095 | import from TempA all; | |
32096 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32097 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32098 | ||
32099 | const BERPDU myValue := {b := true, | |
32100 | c := 5 } | |
32101 | ||
32102 | <TTCN_TC:EXEC> | |
32103 | ||
32104 | ||
32105 | ||
32106 | ||
32107 | if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32108 | ||
32109 | <RESULT> | |
32110 | ||
32111 | Overall verdict: pass | |
32112 | ||
32113 | <END_TC> | |
32114 | ||
32115 | :exmp. | |
32116 | ||
32117 | .*---------------------------------------------------------------------* | |
32118 | :h3.CER + DER encoding of TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT | |
32119 | .*---------------------------------------------------------------------* | |
32120 | :xmp tab=0. | |
32121 | ||
32122 | <TC - CER + DER encoding of TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT> | |
32123 | ||
32124 | <STATIC:ASN> | |
32125 | ||
32126 | TempA | |
32127 | ||
32128 | DEFINITIONS | |
32129 | ||
32130 | AUTOMATIC TAGS | |
32131 | ||
32132 | ::= | |
32133 | ||
32134 | BEGIN | |
32135 | ||
32136 | BERPDU ::= [0] SET | |
32137 | { | |
32138 | b [0] BOOLEAN OPTIONAL, | |
32139 | c [1] INTEGER OPTIONAL | |
32140 | } | |
32141 | ||
32142 | ||
32143 | END | |
32144 | ||
32145 | <STATIC> | |
32146 | ||
32147 | import from TempA all; | |
32148 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32149 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32150 | ||
32151 | const BERPDU myValue := {b := true, | |
32152 | c := 5 } | |
32153 | ||
32154 | <TTCN_TC:EXEC> | |
32155 | ||
32156 | ||
32157 | ||
32158 | ||
32159 | if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32160 | ||
32161 | ||
32162 | <RESULT> | |
32163 | ||
32164 | Overall verdict: pass | |
32165 | ||
32166 | <END_TC> | |
32167 | ||
32168 | :exmp. | |
32169 | ||
32170 | .*---------------------------------------------------------------------* | |
32171 | :h3.encoding of TAGGED SET (different order) (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT | |
32172 | .*---------------------------------------------------------------------* | |
32173 | :xmp tab=0. | |
32174 | ||
32175 | <TC - encoding of TAGGED SET (different order) (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT> | |
32176 | ||
32177 | <STATIC:ASN> | |
32178 | ||
32179 | TempA | |
32180 | ||
32181 | DEFINITIONS | |
32182 | ||
32183 | AUTOMATIC TAGS | |
32184 | ||
32185 | ::= | |
32186 | ||
32187 | BEGIN | |
32188 | ||
32189 | BERPDU ::= [0] SET | |
32190 | { | |
32191 | b [0] BOOLEAN OPTIONAL, | |
32192 | c [1] INTEGER OPTIONAL | |
32193 | } | |
32194 | ||
32195 | ||
32196 | END | |
32197 | ||
32198 | <STATIC> | |
32199 | ||
32200 | import from TempA all; | |
32201 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32202 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32203 | ||
32204 | const BERPDU myValue := { | |
32205 | c := 5, | |
32206 | b := true } | |
32207 | ||
32208 | <TTCN_TC:EXEC> | |
32209 | ||
32210 | ||
32211 | ||
32212 | ||
32213 | if ((enc_DER_PDU(myValue) == 'A0068001FF810105'O)and(enc_CER_PDU(myValue) == 'A0808001FF8101050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32214 | ||
32215 | ||
32216 | <RESULT> | |
32217 | ||
32218 | Overall verdict: pass | |
32219 | ||
32220 | <END_TC> | |
32221 | ||
32222 | :exmp. | |
32223 | ||
32224 | .*---------------------------------------------------------------------* | |
32225 | :h3.CER + DER encoding of TAGGED SET (different order2) (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT | |
32226 | .*---------------------------------------------------------------------* | |
32227 | :xmp tab=0. | |
32228 | ||
32229 | <TC - CER + DER encoding of TAGGED SET (different order2) (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT> | |
32230 | ||
32231 | <STATIC:ASN> | |
32232 | ||
32233 | TempA | |
32234 | ||
32235 | DEFINITIONS | |
32236 | ||
32237 | AUTOMATIC TAGS | |
32238 | ||
32239 | ::= | |
32240 | ||
32241 | BEGIN | |
32242 | ||
32243 | BERPDU ::= [0] SET | |
32244 | { | |
32245 | ||
32246 | c [0] INTEGER OPTIONAL, | |
32247 | b [1] BOOLEAN OPTIONAL | |
32248 | } | |
32249 | ||
32250 | ||
32251 | END | |
32252 | ||
32253 | <STATIC> | |
32254 | ||
32255 | import from TempA all; | |
32256 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32257 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32258 | ||
32259 | const BERPDU myValue := {b := true, | |
32260 | c := 5 } | |
32261 | ||
32262 | <TTCN_TC:EXEC> | |
32263 | ||
32264 | ||
32265 | ||
32266 | ||
32267 | if ((enc_DER_PDU(myValue) == 'A0068001058101FF'O)and(enc_CER_PDU(myValue) == 'A0808001058101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32268 | ||
32269 | ||
32270 | <RESULT> | |
32271 | ||
32272 | Overall verdict: pass | |
32273 | ||
32274 | <END_TC> | |
32275 | ||
32276 | :exmp. | |
32277 | ||
32278 | .*---------------------------------------------------------------------* | |
32279 | :h3.CER + DER encoding of SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT | |
32280 | .*---------------------------------------------------------------------* | |
32281 | :xmp tab=0. | |
32282 | ||
32283 | <TC - CER + DER encoding of SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT> | |
32284 | ||
32285 | <STATIC:ASN> | |
32286 | ||
32287 | TempA | |
32288 | ||
32289 | DEFINITIONS | |
32290 | ||
32291 | AUTOMATIC TAGS | |
32292 | ||
32293 | ::= | |
32294 | ||
32295 | BEGIN | |
32296 | ||
32297 | BERPDU ::= SET | |
32298 | { | |
32299 | b [5] BOOLEAN OPTIONAL, | |
32300 | c INTEGER OPTIONAL | |
32301 | } | |
32302 | ||
32303 | ||
32304 | END | |
32305 | ||
32306 | <STATIC> | |
32307 | ||
32308 | import from TempA all; | |
32309 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32310 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32311 | ||
32312 | const BERPDU myValue := {b := true, | |
32313 | c := 5 } | |
32314 | ||
32315 | <TTCN_TC:EXEC> | |
32316 | ||
32317 | ||
32318 | ||
32319 | ||
32320 | if ((enc_DER_PDU(myValue) == '31060201058501FF'O)and(enc_CER_PDU(myValue) == '31800201058501FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32321 | ||
32322 | <RESULT> | |
32323 | ||
32324 | Overall verdict: pass | |
32325 | ||
32326 | <END_TC> | |
32327 | ||
32328 | :exmp. | |
32329 | ||
32330 | .*---------------------------------------------------------------------* | |
32331 | :h3. encoding of SET , (different order) one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT | |
32332 | .*---------------------------------------------------------------------* | |
32333 | :xmp tab=0. | |
32334 | ||
32335 | <TC - encoding of SET , (different order) one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT> | |
32336 | ||
32337 | <STATIC:ASN> | |
32338 | ||
32339 | TempA | |
32340 | ||
32341 | DEFINITIONS | |
32342 | ||
32343 | AUTOMATIC TAGS | |
32344 | ||
32345 | ::= | |
32346 | ||
32347 | BEGIN | |
32348 | ||
32349 | BERPDU ::= SET | |
32350 | { | |
32351 | b [5] BOOLEAN OPTIONAL, | |
32352 | c INTEGER OPTIONAL | |
32353 | } | |
32354 | ||
32355 | ||
32356 | END | |
32357 | ||
32358 | <STATIC> | |
32359 | ||
32360 | import from TempA all; | |
32361 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32362 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32363 | ||
32364 | const BERPDU myValue := { c := 5 , | |
32365 | b := true } | |
32366 | ||
32367 | <TTCN_TC:EXEC> | |
32368 | ||
32369 | ||
32370 | ||
32371 | ||
32372 | if ((enc_DER_PDU(myValue) == '31060201058501FF'O)and(enc_CER_PDU(myValue) == '31800201058501FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32373 | ||
32374 | <RESULT> | |
32375 | ||
32376 | Overall verdict: pass | |
32377 | ||
32378 | <END_TC> | |
32379 | ||
32380 | :exmp. | |
32381 | ||
32382 | .*---------------------------------------------------------------------* | |
32383 | :h3.CER + DER encoding of SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags | |
32384 | .*---------------------------------------------------------------------* | |
32385 | :xmp tab=0. | |
32386 | ||
32387 | <TC - CER + DER encoding of SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags> | |
32388 | ||
32389 | <STATIC:ASN> | |
32390 | ||
32391 | TempA | |
32392 | ||
32393 | DEFINITIONS | |
32394 | ||
32395 | AUTOMATIC TAGS | |
32396 | ||
32397 | ||
32398 | ::= | |
32399 | ||
32400 | BEGIN | |
32401 | ||
32402 | MySeq ::= SET | |
32403 | {x INTEGER OPTIONAL, | |
32404 | y OCTET STRING} | |
32405 | ||
32406 | ||
32407 | ||
32408 | BERPDU ::= SET | |
32409 | { | |
32410 | b BOOLEAN OPTIONAL, | |
32411 | c INTEGER OPTIONAL, | |
32412 | COMPONENTS OF MySeq | |
32413 | } | |
32414 | ||
32415 | ||
32416 | END | |
32417 | ||
32418 | <STATIC> | |
32419 | ||
32420 | import from TempA all; | |
32421 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32422 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32423 | ||
32424 | const BERPDU myValue := {b := true, | |
32425 | c := 5 , | |
32426 | x := 6, | |
32427 | y := 'FF'O } | |
32428 | ||
32429 | <TTCN_TC:EXEC> | |
32430 | ||
32431 | ||
32432 | ||
32433 | ||
32434 | if ((enc_DER_PDU(myValue) == '310C8001FF8101058201068301FF'O)and(enc_CER_PDU(myValue) == '31808001FF8101058201068301FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32435 | ||
32436 | <RESULT> | |
32437 | ||
32438 | Overall verdict: pass | |
32439 | ||
32440 | <END_TC> | |
32441 | ||
32442 | :exmp. | |
32443 | ||
32444 | .*---------------------------------------------------------------------* | |
32445 | :h3. encoding of SET (different order) ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags | |
32446 | .*---------------------------------------------------------------------* | |
32447 | :xmp tab=0. | |
32448 | ||
32449 | <TC - encoding of SET (different order) ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags> | |
32450 | ||
32451 | <STATIC:ASN> | |
32452 | ||
32453 | TempA | |
32454 | ||
32455 | DEFINITIONS | |
32456 | ||
32457 | AUTOMATIC TAGS | |
32458 | ||
32459 | ||
32460 | ::= | |
32461 | ||
32462 | BEGIN | |
32463 | ||
32464 | MySeq ::= SET | |
32465 | {y OCTET STRING, | |
32466 | ||
32467 | x INTEGER OPTIONAL | |
32468 | } | |
32469 | ||
32470 | ||
32471 | ||
32472 | BERPDU ::= SET | |
32473 | { | |
32474 | b BOOLEAN OPTIONAL, | |
32475 | c INTEGER OPTIONAL, | |
32476 | COMPONENTS OF MySeq | |
32477 | } | |
32478 | ||
32479 | ||
32480 | END | |
32481 | ||
32482 | <STATIC> | |
32483 | ||
32484 | import from TempA all; | |
32485 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32486 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32487 | ||
32488 | const BERPDU myValue := {b := true, | |
32489 | c := 5 , | |
32490 | x := 6, | |
32491 | y := 'FF'O } | |
32492 | ||
32493 | <TTCN_TC:EXEC> | |
32494 | ||
32495 | ||
32496 | ||
32497 | ||
32498 | if ((enc_DER_PDU(myValue) == '310C8001FF8101058201FF830106'O)and(enc_CER_PDU(myValue) == '31808001FF8101058201FF8301060000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32499 | ||
32500 | <RESULT> | |
32501 | ||
32502 | Overall verdict: pass | |
32503 | ||
32504 | <END_TC> | |
32505 | ||
32506 | :exmp. | |
32507 | ||
32508 | .*---------------------------------------------------------------------* | |
32509 | :h3.CER + DER encoding of SET , one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
32510 | .*---------------------------------------------------------------------* | |
32511 | :xmp tab=0. | |
32512 | ||
32513 | <TC - CER + DER encoding of SET , one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
32514 | ||
32515 | <STATIC:ASN> | |
32516 | ||
32517 | TempA | |
32518 | ||
32519 | DEFINITIONS | |
32520 | ||
32521 | AUTOMATIC TAGS | |
32522 | ||
32523 | ::= | |
32524 | ||
32525 | BEGIN | |
32526 | ||
32527 | MySeq ::= SET | |
32528 | {x [0] INTEGER OPTIONAL, | |
32529 | y OCTET STRING} | |
32530 | ||
32531 | ||
32532 | ||
32533 | BERPDU ::= SET | |
32534 | { | |
32535 | b BOOLEAN OPTIONAL, | |
32536 | c INTEGER OPTIONAL, | |
32537 | COMPONENTS OF MySeq | |
32538 | } | |
32539 | ||
32540 | ||
32541 | END | |
32542 | ||
32543 | <STATIC> | |
32544 | ||
32545 | import from TempA all; | |
32546 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32547 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32548 | ||
32549 | const BERPDU myValue := {b := true, | |
32550 | c := 5 , | |
32551 | x := 6, | |
32552 | y := 'FF'O } | |
32553 | ||
32554 | <TTCN_TC:EXEC> | |
32555 | ||
32556 | ||
32557 | ||
32558 | ||
32559 | if ((enc_DER_PDU(myValue) == '310C8001FF8101058201068301FF'O)and(enc_CER_PDU(myValue) == '31808001FF8101058201068301FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32560 | ||
32561 | <RESULT> | |
32562 | ||
32563 | Overall verdict: pass | |
32564 | ||
32565 | <END_TC> | |
32566 | ||
32567 | :exmp. | |
32568 | ||
32569 | .*---------------------------------------------------------------------* | |
32570 | :h3.CER + DER encoding of SET , (different order) one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
32571 | .*---------------------------------------------------------------------* | |
32572 | :xmp tab=0. | |
32573 | ||
32574 | <TC - CER + DER encoding of SET , (different order) one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
32575 | ||
32576 | <STATIC:ASN> | |
32577 | ||
32578 | TempA | |
32579 | ||
32580 | DEFINITIONS | |
32581 | ||
32582 | AUTOMATIC TAGS | |
32583 | ||
32584 | ::= | |
32585 | ||
32586 | BEGIN | |
32587 | ||
32588 | MySeq ::= SET | |
32589 | {y OCTET STRING, | |
32590 | ||
32591 | x [0] INTEGER OPTIONAL | |
32592 | } | |
32593 | ||
32594 | ||
32595 | ||
32596 | BERPDU ::= SET | |
32597 | { | |
32598 | b BOOLEAN OPTIONAL, | |
32599 | c INTEGER OPTIONAL, | |
32600 | COMPONENTS OF MySeq | |
32601 | } | |
32602 | ||
32603 | ||
32604 | END | |
32605 | ||
32606 | <STATIC> | |
32607 | ||
32608 | import from TempA all; | |
32609 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32610 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32611 | ||
32612 | const BERPDU myValue := {b := true, | |
32613 | c := 5 , | |
32614 | x := 6, | |
32615 | y := 'FF'O } | |
32616 | ||
32617 | <TTCN_TC:EXEC> | |
32618 | ||
32619 | ||
32620 | ||
32621 | ||
32622 | if ((enc_DER_PDU(myValue) == '310C8001FF8101058201FF830106'O)and(enc_CER_PDU(myValue) == '31808001FF8101058201FF8301060000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32623 | ||
32624 | <RESULT> | |
32625 | ||
32626 | Overall verdict: pass | |
32627 | ||
32628 | <END_TC> | |
32629 | ||
32630 | :exmp. | |
32631 | ||
32632 | .*---------------------------------------------------------------------* | |
32633 | :h3.CER + DER encoding of SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
32634 | .*---------------------------------------------------------------------* | |
32635 | :xmp tab=0. | |
32636 | ||
32637 | <TC - CER + DER encoding of SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
32638 | ||
32639 | <STATIC:ASN> | |
32640 | ||
32641 | TempA | |
32642 | ||
32643 | DEFINITIONS | |
32644 | ||
32645 | AUTOMATIC TAGS | |
32646 | ||
32647 | ::= | |
32648 | ||
32649 | BEGIN | |
32650 | ||
32651 | ||
32652 | MySeq ::= SET | |
32653 | {x INTEGER OPTIONAL, | |
32654 | y OCTET STRING} | |
32655 | ||
32656 | ||
32657 | ||
32658 | BERPDU ::= SET | |
32659 | { | |
32660 | b [0] BOOLEAN OPTIONAL, | |
32661 | c BIT STRING OPTIONAL, | |
32662 | COMPONENTS OF MySeq | |
32663 | } | |
32664 | ||
32665 | ||
32666 | END | |
32667 | ||
32668 | <STATIC> | |
32669 | ||
32670 | import from TempA all; | |
32671 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32672 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32673 | ||
32674 | const BERPDU myValue := {b := true, | |
32675 | c := '1'B , | |
32676 | x := 6, | |
32677 | y := 'FF'O } | |
32678 | ||
32679 | <TTCN_TC:EXEC> | |
32680 | ||
32681 | ||
32682 | ||
32683 | ||
32684 | if ((enc_DER_PDU(myValue) == '310D020106030207800401FF8001FF'O)and(enc_CER_PDU(myValue) == '3180020106030207800401FF8001FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32685 | ||
32686 | <RESULT> | |
32687 | ||
32688 | Overall verdict: pass | |
32689 | ||
32690 | <END_TC> | |
32691 | ||
32692 | :exmp. | |
32693 | ||
32694 | .*---------------------------------------------------------------------* | |
32695 | :h3.CER + DER encoding of SET , (different order)one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
32696 | .*---------------------------------------------------------------------* | |
32697 | :xmp tab=0. | |
32698 | ||
32699 | <TC - CER + DER encoding of SET , (different order)one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
32700 | ||
32701 | <STATIC:ASN> | |
32702 | ||
32703 | TempA | |
32704 | ||
32705 | DEFINITIONS | |
32706 | ||
32707 | AUTOMATIC TAGS | |
32708 | ||
32709 | ::= | |
32710 | ||
32711 | BEGIN | |
32712 | ||
32713 | ||
32714 | MySeq ::= SET | |
32715 | {y OCTET STRING, | |
32716 | x INTEGER OPTIONAL | |
32717 | } | |
32718 | ||
32719 | ||
32720 | ||
32721 | BERPDU ::= SET | |
32722 | { | |
32723 | b [0] BOOLEAN OPTIONAL, | |
32724 | c BIT STRING OPTIONAL, | |
32725 | COMPONENTS OF MySeq | |
32726 | } | |
32727 | ||
32728 | ||
32729 | END | |
32730 | ||
32731 | <STATIC> | |
32732 | ||
32733 | import from TempA all; | |
32734 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32735 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32736 | ||
32737 | const BERPDU myValue := {b := true, | |
32738 | c := '1'B , | |
32739 | x := 6, | |
32740 | y := 'FF'O } | |
32741 | ||
32742 | <TTCN_TC:EXEC> | |
32743 | ||
32744 | ||
32745 | ||
32746 | ||
32747 | if ((enc_DER_PDU(myValue) == '310D020106030207800401FF8001FF'O)and(enc_CER_PDU(myValue) == '3180020106030207800401FF8001FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32748 | ||
32749 | <RESULT> | |
32750 | ||
32751 | Overall verdict: pass | |
32752 | ||
32753 | <END_TC> | |
32754 | ||
32755 | :exmp. | |
32756 | ||
32757 | .*---------------------------------------------------------------------* | |
32758 | :h3.CER + DER encoding of SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
32759 | .*---------------------------------------------------------------------* | |
32760 | :xmp tab=0. | |
32761 | ||
32762 | <TC - CER + DER encoding of SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
32763 | ||
32764 | <STATIC:ASN> | |
32765 | ||
32766 | TempA | |
32767 | ||
32768 | DEFINITIONS | |
32769 | ||
32770 | AUTOMATIC TAGS | |
32771 | ||
32772 | ::= | |
32773 | ||
32774 | BEGIN | |
32775 | ||
32776 | MySeq ::= SET | |
32777 | {x [1] INTEGER OPTIONAL, | |
32778 | y OCTET STRING} | |
32779 | ||
32780 | ||
32781 | ||
32782 | BERPDU ::= SET | |
32783 | { | |
32784 | b [0] BOOLEAN OPTIONAL, | |
32785 | c BIT STRING OPTIONAL, | |
32786 | COMPONENTS OF MySeq | |
32787 | } | |
32788 | ||
32789 | ||
32790 | ||
32791 | END | |
32792 | ||
32793 | <STATIC> | |
32794 | ||
32795 | import from TempA all; | |
32796 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32797 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32798 | ||
32799 | const BERPDU myValue := {b := true, | |
32800 | c := '1'B , | |
32801 | x := 6, | |
32802 | y := 'FF'O } | |
32803 | ||
32804 | <TTCN_TC:EXEC> | |
32805 | 030 | |
32806 | ||
32807 | ||
32808 | ||
32809 | if ((enc_DER_PDU(myValue) == '310D030207800401FF8001FF810106'O)and(enc_CER_PDU(myValue) == '3180030207800401FF8001FF8101060000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32810 | ||
32811 | <RESULT> | |
32812 | ||
32813 | Overall verdict: pass | |
32814 | ||
32815 | <END_TC> | |
32816 | ||
32817 | :exmp. | |
32818 | ||
32819 | .*---------------------------------------------------------------------* | |
32820 | :h3.CER + DER encoding of SET ,(different order) one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
32821 | .*---------------------------------------------------------------------* | |
32822 | :xmp tab=0. | |
32823 | ||
32824 | <TC - CER + DER encoding of SET ,(different order) one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
32825 | ||
32826 | <STATIC:ASN> | |
32827 | ||
32828 | TempA | |
32829 | ||
32830 | DEFINITIONS | |
32831 | ||
32832 | AUTOMATIC TAGS | |
32833 | ||
32834 | ::= | |
32835 | ||
32836 | BEGIN | |
32837 | ||
32838 | MySeq ::= SET | |
32839 | { y OCTET STRING, | |
32840 | x [1] INTEGER OPTIONAL | |
32841 | } | |
32842 | ||
32843 | ||
32844 | ||
32845 | BERPDU ::= SET | |
32846 | { | |
32847 | b [0] BOOLEAN OPTIONAL, | |
32848 | c BIT STRING OPTIONAL, | |
32849 | COMPONENTS OF MySeq | |
32850 | } | |
32851 | ||
32852 | ||
32853 | ||
32854 | END | |
32855 | ||
32856 | <STATIC> | |
32857 | ||
32858 | import from TempA all; | |
32859 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32860 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32861 | ||
32862 | const BERPDU myValue := {b := true, | |
32863 | c := '1'B , | |
32864 | x := 6, | |
32865 | y := 'FF'O } | |
32866 | ||
32867 | <TTCN_TC:EXEC> | |
32868 | ||
32869 | ||
32870 | ||
32871 | ||
32872 | if ((enc_DER_PDU(myValue) == '310D030207800401FF8001FF810106'O)and(enc_CER_PDU(myValue) == '3180030207800401FF8001FF8101060000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32873 | ||
32874 | <RESULT> | |
32875 | ||
32876 | Overall verdict: pass | |
32877 | ||
32878 | <END_TC> | |
32879 | ||
32880 | :exmp. | |
32881 | ||
32882 | .*---------------------------------------------------------------------* | |
32883 | :h3.CER + DER encoding of SET with CHOICE element, AUTOMATIC TAGS | |
32884 | .*---------------------------------------------------------------------* | |
32885 | :xmp tab=0. | |
32886 | ||
32887 | <TC - CER + DER encoding of SET with CHOICE element, AUTOMATIC TAGS> | |
32888 | ||
32889 | <STATIC:ASN> | |
32890 | ||
32891 | TempA | |
32892 | ||
32893 | DEFINITIONS | |
32894 | ||
32895 | AUTOMATIC TAGS | |
32896 | ||
32897 | ::= | |
32898 | ||
32899 | BEGIN | |
32900 | ||
32901 | ||
32902 | ||
32903 | ||
32904 | BERPDU ::= SET | |
32905 | { | |
32906 | b CHOICE { | |
32907 | x BOOLEAN, | |
32908 | y OCTET STRING | |
32909 | } | |
32910 | OPTIONAL, | |
32911 | ||
32912 | ||
32913 | c INTEGER OPTIONAL | |
32914 | ||
32915 | } | |
32916 | ||
32917 | ||
32918 | ||
32919 | END | |
32920 | ||
32921 | <STATIC> | |
32922 | ||
32923 | import from TempA all; | |
32924 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32925 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32926 | ||
32927 | const BERPDU myValue := {b := {x := true}, | |
32928 | c := 4 | |
32929 | } | |
32930 | <TTCN_TC:EXEC> | |
32931 | ||
32932 | ||
32933 | ||
32934 | ||
32935 | if ((enc_DER_PDU(myValue) == '3108A0038001FF810104'O)and(enc_CER_PDU(myValue) == '3180A0808001FF00008101040000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32936 | ||
32937 | <RESULT> | |
32938 | ||
32939 | Overall verdict: pass | |
32940 | ||
32941 | <END_TC> | |
32942 | ||
32943 | :exmp. | |
32944 | ||
32945 | .*---------------------------------------------------------------------* | |
32946 | :h3. encoding of SET with CHOICE element (different order), AUTOMATIC TAGS | |
32947 | .*---------------------------------------------------------------------* | |
32948 | :xmp tab=0. | |
32949 | ||
32950 | <TC - encoding of SET with CHOICE element (different order), AUTOMATIC TAGS> | |
32951 | ||
32952 | <STATIC:ASN> | |
32953 | ||
32954 | TempA | |
32955 | ||
32956 | DEFINITIONS | |
32957 | ||
32958 | AUTOMATIC TAGS | |
32959 | ||
32960 | ::= | |
32961 | ||
32962 | BEGIN | |
32963 | ||
32964 | ||
32965 | ||
32966 | ||
32967 | BERPDU ::= SET | |
32968 | { | |
32969 | b CHOICE { | |
32970 | x BOOLEAN, | |
32971 | y OCTET STRING | |
32972 | } | |
32973 | OPTIONAL, | |
32974 | ||
32975 | ||
32976 | c INTEGER OPTIONAL | |
32977 | ||
32978 | } | |
32979 | ||
32980 | ||
32981 | ||
32982 | END | |
32983 | ||
32984 | <STATIC> | |
32985 | ||
32986 | import from TempA all; | |
32987 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
32988 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
32989 | ||
32990 | const BERPDU myValue := { | |
32991 | c := 4, | |
32992 | b := {x := true} } | |
32993 | <TTCN_TC:EXEC> | |
32994 | ||
32995 | ||
32996 | ||
32997 | ||
32998 | if ((enc_DER_PDU(myValue) == '3108A0038001FF810104'O)and(enc_CER_PDU(myValue) == '3180A0808001FF00008101040000'O)) {setverdict(pass);} else {setverdict(fail);} | |
32999 | ||
33000 | <RESULT> | |
33001 | ||
33002 | Overall verdict: pass | |
33003 | ||
33004 | <END_TC> | |
33005 | ||
33006 | :exmp. | |
33007 | ||
33008 | .*---------------------------------------------------------------------* | |
33009 | :h3. encoding of SET with CHOICE element (different order2), AUTOMATIC TAGS | |
33010 | .*---------------------------------------------------------------------* | |
33011 | :xmp tab=0. | |
33012 | ||
33013 | <TC - encoding of SET with CHOICE element (different order2), AUTOMATIC TAGS> | |
33014 | ||
33015 | <STATIC:ASN> | |
33016 | ||
33017 | TempA | |
33018 | ||
33019 | DEFINITIONS | |
33020 | ||
33021 | AUTOMATIC TAGS | |
33022 | ||
33023 | ::= | |
33024 | ||
33025 | BEGIN | |
33026 | ||
33027 | ||
33028 | ||
33029 | ||
33030 | BERPDU ::= SET | |
33031 | { | |
33032 | ||
33033 | ||
33034 | c INTEGER OPTIONAL, | |
33035 | b CHOICE { | |
33036 | x BOOLEAN, | |
33037 | y OCTET STRING | |
33038 | } | |
33039 | OPTIONAL | |
33040 | ||
33041 | } | |
33042 | ||
33043 | ||
33044 | ||
33045 | END | |
33046 | ||
33047 | <STATIC> | |
33048 | ||
33049 | import from TempA all; | |
33050 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
33051 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
33052 | ||
33053 | const BERPDU myValue := { | |
33054 | c := 4, | |
33055 | b := {x := true} } | |
33056 | <TTCN_TC:EXEC> | |
33057 | ||
33058 | ||
33059 | ||
33060 | ||
33061 | if ((enc_DER_PDU(myValue) == '3108800104A1038001FF'O)and(enc_CER_PDU(myValue) == '3180800104A1808001FF00000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
33062 | ||
33063 | <RESULT> | |
33064 | ||
33065 | Overall verdict: pass | |
33066 | ||
33067 | <END_TC> | |
33068 | ||
33069 | :exmp. | |
33070 | ||
33071 | .*---------------------------------------------------------------------* | |
33072 | :h3.CER + DER encoding of SET with CHOICE element, | |
33073 | .*---------------------------------------------------------------------* | |
33074 | :xmp tab=0. | |
33075 | ||
33076 | <TC - CER + DER encoding of SET with CHOICE element, > | |
33077 | ||
33078 | <STATIC:ASN> | |
33079 | ||
33080 | TempA | |
33081 | ||
33082 | DEFINITIONS | |
33083 | ||
33084 | ||
33085 | ||
33086 | ::= | |
33087 | ||
33088 | BEGIN | |
33089 | ||
33090 | ||
33091 | ||
33092 | ||
33093 | BERPDU ::= SET | |
33094 | { | |
33095 | b CHOICE { | |
33096 | x BOOLEAN, | |
33097 | y OCTET STRING | |
33098 | } | |
33099 | OPTIONAL, | |
33100 | ||
33101 | ||
33102 | c INTEGER OPTIONAL | |
33103 | ||
33104 | } | |
33105 | ||
33106 | ||
33107 | ||
33108 | END | |
33109 | ||
33110 | <STATIC> | |
33111 | ||
33112 | import from TempA all; | |
33113 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
33114 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
33115 | ||
33116 | const BERPDU myValue := {b := {x := true}, | |
33117 | c := 4 | |
33118 | } | |
33119 | <TTCN_TC:EXEC> | |
33120 | ||
33121 | ||
33122 | ||
33123 | ||
33124 | if ((enc_DER_PDU(myValue) == '31060101FF020104'O)and(enc_CER_PDU(myValue) == '31800101FF0201040000'O)) {setverdict(pass);} else {setverdict(fail);} | |
33125 | ||
33126 | <RESULT> | |
33127 | ||
33128 | Overall verdict: pass | |
33129 | ||
33130 | <END_TC> | |
33131 | ||
33132 | :exmp. | |
33133 | ||
33134 | .*---------------------------------------------------------------------* | |
33135 | :h3. encoding of SET with CHOICE element,(different order) | |
33136 | .*---------------------------------------------------------------------* | |
33137 | :xmp tab=0. | |
33138 | ||
33139 | <TC - encoding of SET with CHOICE element,(different order) > | |
33140 | ||
33141 | <STATIC:ASN> | |
33142 | ||
33143 | TempA | |
33144 | ||
33145 | DEFINITIONS | |
33146 | ||
33147 | ||
33148 | ||
33149 | ::= | |
33150 | ||
33151 | BEGIN | |
33152 | ||
33153 | ||
33154 | ||
33155 | ||
33156 | BERPDU ::= SET | |
33157 | { | |
33158 | b CHOICE { | |
33159 | x BOOLEAN, | |
33160 | y OCTET STRING | |
33161 | } | |
33162 | OPTIONAL, | |
33163 | ||
33164 | ||
33165 | c INTEGER OPTIONAL | |
33166 | ||
33167 | } | |
33168 | ||
33169 | ||
33170 | ||
33171 | END | |
33172 | ||
33173 | <STATIC> | |
33174 | ||
33175 | import from TempA all; | |
33176 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
33177 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
33178 | ||
33179 | const BERPDU myValue := { | |
33180 | c := 4 , | |
33181 | b := {x := true} | |
33182 | } | |
33183 | <TTCN_TC:EXEC> | |
33184 | ||
33185 | ||
33186 | ||
33187 | ||
33188 | if ((enc_DER_PDU(myValue) == '31060101FF020104'O)and(enc_CER_PDU(myValue) == '31800101FF0201040000'O)) {setverdict(pass);} else {setverdict(fail);} | |
33189 | ||
33190 | <RESULT> | |
33191 | ||
33192 | Overall verdict: pass | |
33193 | ||
33194 | <END_TC> | |
33195 | ||
33196 | :exmp. | |
33197 | ||
33198 | .*---------------------------------------------------------------------* | |
33199 | :h3.CER + DER encoding of SET with CHOICE element, | |
33200 | .*---------------------------------------------------------------------* | |
33201 | :xmp tab=0. | |
33202 | ||
33203 | <TC - CER + DER encoding of SET with CHOICE element, > | |
33204 | ||
33205 | <STATIC:ASN> | |
33206 | ||
33207 | TempA | |
33208 | ||
33209 | DEFINITIONS | |
33210 | ||
33211 | ||
33212 | ||
33213 | ::= | |
33214 | ||
33215 | BEGIN | |
33216 | ||
33217 | ||
33218 | ||
33219 | ||
33220 | BERPDU ::= SET | |
33221 | { | |
33222 | b CHOICE { | |
33223 | x BOOLEAN, | |
33224 | y OCTET STRING | |
33225 | } | |
33226 | OPTIONAL, | |
33227 | ||
33228 | ||
33229 | c INTEGER OPTIONAL | |
33230 | ||
33231 | } | |
33232 | ||
33233 | ||
33234 | ||
33235 | END | |
33236 | ||
33237 | <STATIC> | |
33238 | ||
33239 | import from TempA all; | |
33240 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
33241 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
33242 | ||
33243 | const BERPDU myValue := {b := {y := 'FF'O}, | |
33244 | c := 4 | |
33245 | } | |
33246 | <TTCN_TC:EXEC> | |
33247 | ||
33248 | ||
33249 | ||
33250 | ||
33251 | if ((enc_DER_PDU(myValue) == '31060201040401FF'O)and(enc_CER_PDU(myValue) == '31800401FF0201040000'O)) {setverdict(pass);} else {setverdict(fail);} | |
33252 | ||
33253 | <RESULT> | |
33254 | ||
33255 | Overall verdict: pass | |
33256 | ||
33257 | <END_TC> | |
33258 | ||
33259 | :exmp. | |
33260 | ||
33261 | .*---------------------------------------------------------------------* | |
33262 | :h3.CER + DER encoding of SET with EXTENSION , AUTOMATIC TAGS | |
33263 | .*---------------------------------------------------------------------* | |
33264 | :xmp tab=0. | |
33265 | ||
33266 | <TC - CER + DER encoding of SET with EXTENSION , AUTOMATIC TAGS> | |
33267 | ||
33268 | <STATIC:ASN> | |
33269 | ||
33270 | TempA | |
33271 | ||
33272 | DEFINITIONS | |
33273 | ||
33274 | AUTOMATIC TAGS | |
33275 | ||
33276 | ::= | |
33277 | ||
33278 | BEGIN | |
33279 | ||
33280 | ||
33281 | ||
33282 | ||
33283 | BERPDU ::= SET | |
33284 | { | |
33285 | ||
33286 | a OCTET STRING, | |
33287 | ||
33288 | b BOOLEAN, | |
33289 | ||
33290 | c INTEGER OPTIONAL, | |
33291 | ||
33292 | ..., | |
33293 | ||
33294 | d BIT STRING | |
33295 | ||
33296 | ||
33297 | ||
33298 | ||
33299 | } | |
33300 | ||
33301 | ||
33302 | ||
33303 | END | |
33304 | ||
33305 | <STATIC> | |
33306 | ||
33307 | import from TempA all; | |
33308 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
33309 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
33310 | ||
33311 | const BERPDU myValue := { | |
33312 | a := 'FF'O, | |
33313 | b := true, | |
33314 | d := '1'B, | |
33315 | c := 4 | |
33316 | } | |
33317 | <TTCN_TC:EXEC> | |
33318 | ||
33319 | ||
33320 | ||
33321 | ||
33322 | if ((enc_DER_PDU(myValue) == '310D8001FF8101FF82010483020780'O)and(enc_CER_PDU(myValue) == '31808001FF8101FF820104830207800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
33323 | ||
33324 | <RESULT> | |
33325 | ||
33326 | Overall verdict: pass | |
33327 | ||
33328 | <END_TC> | |
33329 | ||
33330 | :exmp. | |
33331 | ||
33332 | .*---------------------------------------------------------------------* | |
33333 | :h3. encoding of SET with EXTENSION , (different order) AUTOMATIC TAGS | |
33334 | .*---------------------------------------------------------------------* | |
33335 | :xmp tab=0. | |
33336 | ||
33337 | <TC - encoding of SET with EXTENSION , (different order) AUTOMATIC TAGS> | |
33338 | ||
33339 | <STATIC:ASN> | |
33340 | ||
33341 | TempA | |
33342 | ||
33343 | DEFINITIONS | |
33344 | ||
33345 | AUTOMATIC TAGS | |
33346 | ||
33347 | ::= | |
33348 | ||
33349 | BEGIN | |
33350 | ||
33351 | ||
33352 | ||
33353 | ||
33354 | BERPDU ::= SET | |
33355 | { | |
33356 | ||
33357 | a OCTET STRING, | |
33358 | ||
33359 | b BOOLEAN, | |
33360 | ||
33361 | c INTEGER OPTIONAL, | |
33362 | ||
33363 | ..., | |
33364 | ||
33365 | d BIT STRING | |
33366 | ||
33367 | ||
33368 | ||
33369 | ||
33370 | } | |
33371 | ||
33372 | ||
33373 | ||
33374 | END | |
33375 | ||
33376 | <STATIC> | |
33377 | ||
33378 | import from TempA all; | |
33379 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
33380 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
33381 | ||
33382 | const BERPDU myValue := { | |
33383 | a := 'FF'O, | |
33384 | d := '1'B, | |
33385 | b := true, | |
33386 | c := 4 | |
33387 | } | |
33388 | <TTCN_TC:EXEC> | |
33389 | ||
33390 | ||
33391 | ||
33392 | ||
33393 | if ((enc_DER_PDU(myValue) == '310D8001FF8101FF82010483020780'O)and(enc_CER_PDU(myValue) == '31808001FF8101FF820104830207800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
33394 | ||
33395 | <RESULT> | |
33396 | ||
33397 | Overall verdict: pass | |
33398 | ||
33399 | <END_TC> | |
33400 | ||
33401 | :exmp. | |
33402 | ||
33403 | .*---------------------------------------------------------------------* | |
33404 | :h3.CER + DER encoding of SET (EMPTY) | |
33405 | .*---------------------------------------------------------------------* | |
33406 | :xmp tab=0. | |
33407 | ||
33408 | <TC - CER + DER encoding of SET (EMPTY)> | |
33409 | ||
33410 | <STATIC:ASN> | |
33411 | ||
33412 | TempA | |
33413 | ||
33414 | DEFINITIONS ::= | |
33415 | BEGIN | |
33416 | ||
33417 | BERPDU ::= SET | |
33418 | { | |
33419 | a NULL, | |
33420 | b BOOLEAN, | |
33421 | c INTEGER, | |
33422 | d ENUMERATED {first ,second ,third}, | |
33423 | e REAL, | |
33424 | f BIT STRING, | |
33425 | g OCTET STRING, | |
33426 | ||
33427 | h OBJECT IDENTIFIER, | |
33428 | i IA5String, | |
33429 | j CHOICE {x1 [1] BOOLEAN, | |
33430 | y1 [2] OCTET STRING}, | |
33431 | ||
33432 | k SEQUENCE{x2 NULL, | |
33433 | y2 BOOLEAN}, | |
33434 | ||
33435 | l SET { x3 BIT STRING, | |
33436 | y3 REAL}, | |
33437 | ||
33438 | m [3] SEQUENCE OF INTEGER, | |
33439 | n [4] SET OF BOOLEAN | |
33440 | } | |
33441 | ||
33442 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
33443 | ||
33444 | ||
33445 | END | |
33446 | ||
33447 | <STATIC> | |
33448 | ||
33449 | import from TempA all; | |
33450 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
33451 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
33452 | ||
33453 | const BERPDU myValue := {a := NULL, | |
33454 | b := true, | |
33455 | c := 2, | |
33456 | d := first, | |
33457 | e := 1.0, | |
33458 | f := '1'B, | |
33459 | g := 'FFFF'O, | |
33460 | h := myOBJID, | |
33461 | i := "ABC", | |
33462 | j := {x1 := true } , | |
33463 | k := {x2 := NULL, | |
33464 | ||
33465 | y2 := true } , | |
33466 | l := {y3 := 1.0 , | |
33467 | ||
33468 | x3 := '1'B } , | |
33469 | m := | |
33470 | { 1 ,2 } , | |
33471 | n := | |
33472 | { true, true } | |
33473 | } | |
33474 | ||
33475 | ||
33476 | ||
33477 | <TTCN_TC:EXEC> | |
33478 | ||
33479 | ||
33480 | ||
33481 | ||
33482 | if ((enc_DER_PDU(myValue) == '31530101FF020102030207800402FFFF05000603000203090603312E452B300A0100300505000101FF310C03020780090603312E452B301603414243A1030101FFA3083006020101020102A40831060101FF0101FF'O)and(enc_CER_PDU(myValue) == '31800101FF020102030207800402FFFF05000603000203090603312E452B300A0100308005000101FF0000318003020780090603312E452B3000001603414243A1800101FF0000A380308002010102010200000000A48031800101FF0101FF000000000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
33483 | ||
33484 | <RESULT> | |
33485 | ||
33486 | Overall verdict: pass | |
33487 | ||
33488 | <END_TC> | |
33489 | ||
33490 | :exmp. | |
33491 | ||
33492 | .*---------------------------------------------------------------------* | |
33493 | :h3.CER + DER encoding of SET with fields of different types, AUTOMATIC TAGS | |
33494 | .*---------------------------------------------------------------------* | |
33495 | :xmp tab=0. | |
33496 | ||
33497 | <TC - CER + DER encoding of SET with fields of different types, AUTOMATIC TAGS> | |
33498 | ||
33499 | <STATIC:ASN> | |
33500 | ||
33501 | TempA | |
33502 | ||
33503 | DEFINITIONS | |
33504 | ||
33505 | AUTOMATIC TAGS | |
33506 | ||
33507 | ::= | |
33508 | ||
33509 | BEGIN | |
33510 | ||
33511 | BERPDU ::= SET | |
33512 | { | |
33513 | a NULL, | |
33514 | b BOOLEAN, | |
33515 | c INTEGER, | |
33516 | d ENUMERATED {first ,second ,third}, | |
33517 | e REAL, | |
33518 | f BIT STRING, | |
33519 | g OCTET STRING, | |
33520 | ||
33521 | h OBJECT IDENTIFIER, | |
33522 | i IA5String, | |
33523 | j CHOICE {x1 BOOLEAN, | |
33524 | y1 OCTET STRING}, | |
33525 | ||
33526 | k SEQUENCE{x2 NULL, | |
33527 | y2 BOOLEAN}, | |
33528 | ||
33529 | l SET { x3 BIT STRING, | |
33530 | y3 REAL}, | |
33531 | ||
33532 | m SEQUENCE OF INTEGER, | |
33533 | n SET OF BOOLEAN | |
33534 | } | |
33535 | ||
33536 | ||
33537 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
33538 | ||
33539 | ||
33540 | END | |
33541 | ||
33542 | <STATIC> | |
33543 | ||
33544 | import from TempA all; | |
33545 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
33546 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
33547 | ||
33548 | const BERPDU myValue := {a := NULL, | |
33549 | b := true, | |
33550 | c := 2, | |
33551 | d := first, | |
33552 | e := 1.0, | |
33553 | f := '1'B, | |
33554 | g := 'FFFF'O, | |
33555 | h := myOBJID, | |
33556 | i := "ABC", | |
33557 | j := {x1 := true } , | |
33558 | k := {x2 := NULL, | |
33559 | ||
33560 | y2 := true } , | |
33561 | l := {y3 := 1.0 , | |
33562 | ||
33563 | x3 := '1'B } , | |
33564 | m := | |
33565 | { 1 ,2 } , | |
33566 | n := | |
33567 | { true, true } | |
33568 | } | |
33569 | ||
33570 | ||
33571 | ||
33572 | ||
33573 | ||
33574 | <TTCN_TC:EXEC> | |
33575 | ||
33576 | ||
33577 | ||
33578 | ||
33579 | if ((enc_DER_PDU(myValue) == '314F80008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB0C80020780810603312E452B30AC06020101020102AD060101FF0101FF'O)and(enc_CER_PDU(myValue) == '318080008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB8080020780810603312E452B300000AC800201010201020000AD800101FF0101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
33580 | ||
33581 | <RESULT> | |
33582 | ||
33583 | Overall verdict: pass | |
33584 | ||
33585 | <END_TC> | |
33586 | ||
33587 | :exmp. | |
33588 | ||
33589 | .*---------------------------------------------------------------------* | |
33590 | :h3.CER + DER encoding of SET with fields of different types (different order), AUTOMATIC TAGS | |
33591 | .*---------------------------------------------------------------------* | |
33592 | :xmp tab=0. | |
33593 | ||
33594 | <TC - CER + DER encoding of SET with fields of different types (different order), AUTOMATIC TAGS> | |
33595 | ||
33596 | <STATIC:ASN> | |
33597 | ||
33598 | TempA | |
33599 | ||
33600 | DEFINITIONS | |
33601 | ||
33602 | AUTOMATIC TAGS | |
33603 | ||
33604 | ::= | |
33605 | ||
33606 | BEGIN | |
33607 | ||
33608 | BERPDU ::= SET | |
33609 | { | |
33610 | a NULL, | |
33611 | b BOOLEAN, | |
33612 | c INTEGER, | |
33613 | d ENUMERATED {first ,second ,third}, | |
33614 | e REAL, | |
33615 | f BIT STRING, | |
33616 | g OCTET STRING, | |
33617 | ||
33618 | h OBJECT IDENTIFIER, | |
33619 | i IA5String, | |
33620 | j CHOICE {x1 BOOLEAN, | |
33621 | y1 OCTET STRING}, | |
33622 | ||
33623 | k SEQUENCE{x2 NULL, | |
33624 | y2 BOOLEAN}, | |
33625 | ||
33626 | l SET { x3 BIT STRING, | |
33627 | y3 REAL}, | |
33628 | ||
33629 | m SEQUENCE OF INTEGER, | |
33630 | n SET OF BOOLEAN | |
33631 | } | |
33632 | ||
33633 | ||
33634 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
33635 | ||
33636 | ||
33637 | END | |
33638 | ||
33639 | <STATIC> | |
33640 | ||
33641 | import from TempA all; | |
33642 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
33643 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
33644 | ||
33645 | const BERPDU myValue := {a := NULL, | |
33646 | c := 2, | |
33647 | d := first, | |
33648 | e := 1.0, | |
33649 | b := true, | |
33650 | f := '1'B, | |
33651 | g := 'FFFF'O, | |
33652 | ||
33653 | i := "ABC", | |
33654 | j := {x1 := true } , | |
33655 | k := {x2 := NULL, | |
33656 | ||
33657 | y2 := true } , | |
33658 | l := {y3 := 1.0 , | |
33659 | ||
33660 | x3 := '1'B } , | |
33661 | h := myOBJID, | |
33662 | m := | |
33663 | { 1 ,2 } , | |
33664 | n := | |
33665 | { true, true } | |
33666 | } | |
33667 | ||
33668 | ||
33669 | ||
33670 | <TTCN_TC:EXEC> | |
33671 | ||
33672 | if ((enc_DER_PDU(myValue) == '314F80008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB0C80020780810603312E452B30AC06020101020102AD060101FF0101FF'O)and(enc_CER_PDU(myValue) == '318080008101FF820102830100840603312E452B30850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB8080020780810603312E452B300000AC800201010201020000AD800101FF0101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
33673 | ||
33674 | <RESULT> | |
33675 | ||
33676 | Overall verdict: pass | |
33677 | ||
33678 | <END_TC> | |
33679 | ||
33680 | :exmp. | |
33681 | ||
33682 | .*---------------------------------------------------------------------* | |
33683 | :h3.CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGGING | |
33684 | .*---------------------------------------------------------------------* | |
33685 | :xmp tab=0. | |
33686 | ||
33687 | <TC - CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGGING> | |
33688 | ||
33689 | <STATIC:ASN> | |
33690 | ||
33691 | TempA | |
33692 | ||
33693 | DEFINITIONS | |
33694 | ||
33695 | IMPLICIT TAGS | |
33696 | ||
33697 | ||
33698 | ::= | |
33699 | ||
33700 | BEGIN | |
33701 | ||
33702 | BERPDU ::= SET | |
33703 | { | |
33704 | d [PRIVATE 0] INTEGER OPTIONAL, | |
33705 | a INTEGER OPTIONAL, | |
33706 | b [APPLICATION 0] INTEGER OPTIONAL, | |
33707 | c [0] INTEGER OPTIONAL | |
33708 | ||
33709 | } | |
33710 | ||
33711 | ||
33712 | END | |
33713 | ||
33714 | <STATIC> | |
33715 | ||
33716 | import from TempA all; | |
33717 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
33718 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
33719 | ||
33720 | const BERPDU myValue := { | |
33721 | a := 1, | |
33722 | c := 3, | |
33723 | d := 4, | |
33724 | b := 2 } | |
33725 | ||
33726 | <TTCN_TC:EXEC> | |
33727 | ||
33728 | ||
33729 | ||
33730 | ||
33731 | if ((enc_DER_PDU(myValue) == '310C020101400102800103C00104'O)and(enc_CER_PDU(myValue) == '3180020101400102800103C001040000'O)) {setverdict(pass);} else {setverdict(fail);} | |
33732 | ||
33733 | <RESULT> | |
33734 | ||
33735 | Overall verdict: pass | |
33736 | ||
33737 | <END_TC> | |
33738 | ||
33739 | :exmp. | |
33740 | ||
33741 | .*---------------------------------------------------------------------* | |
33742 | :h3.CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) | |
33743 | .*---------------------------------------------------------------------* | |
33744 | :xmp tab=0. | |
33745 | ||
33746 | <TC - CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )> | |
33747 | ||
33748 | <STATIC:ASN> | |
33749 | ||
33750 | TempA | |
33751 | ||
33752 | DEFINITIONS | |
33753 | ||
33754 | ||
33755 | ::= | |
33756 | ||
33757 | BEGIN | |
33758 | ||
33759 | BERPDU ::= SET | |
33760 | { | |
33761 | d [PRIVATE 0] INTEGER OPTIONAL, | |
33762 | a INTEGER OPTIONAL, | |
33763 | b [APPLICATION 0] INTEGER OPTIONAL, | |
33764 | c [0] INTEGER OPTIONAL | |
33765 | ||
33766 | } | |
33767 | ||
33768 | ||
33769 | END | |
33770 | ||
33771 | <STATIC> | |
33772 | ||
33773 | import from TempA all; | |
33774 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
33775 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
33776 | ||
33777 | const BERPDU myValue := { | |
33778 | a := 1, | |
33779 | c := 3, | |
33780 | d := 4, | |
33781 | b := 2 } | |
33782 | ||
33783 | <TTCN_TC:EXEC> | |
33784 | ||
33785 | ||
33786 | ||
33787 | ||
33788 | if ((enc_DER_PDU(myValue) == '31120201016003020102A003020103E003020104'O)and(enc_CER_PDU(myValue) == '318002010160800201020000A0800201030000E08002010400000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
33789 | ||
33790 | <RESULT> | |
33791 | ||
33792 | Overall verdict: pass | |
33793 | ||
33794 | <END_TC> | |
33795 | ||
33796 | :exmp. | |
33797 | ||
33798 | .*---------------------------------------------------------------------* | |
33799 | :h3.CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGGING | |
33800 | .*---------------------------------------------------------------------* | |
33801 | :xmp tab=0. | |
33802 | ||
33803 | <TC - CER + DER encoding of SET (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGGING> | |
33804 | ||
33805 | <STATIC:ASN> | |
33806 | ||
33807 | TempA | |
33808 | ||
33809 | DEFINITIONS | |
33810 | ||
33811 | EXPLICIT TAGS | |
33812 | ||
33813 | ::= | |
33814 | ||
33815 | BEGIN | |
33816 | ||
33817 | BERPDU ::= SET | |
33818 | { | |
33819 | d [PRIVATE 0] INTEGER OPTIONAL, | |
33820 | a INTEGER OPTIONAL, | |
33821 | b [APPLICATION 0] INTEGER OPTIONAL, | |
33822 | c [0] INTEGER OPTIONAL | |
33823 | ||
33824 | } | |
33825 | ||
33826 | ||
33827 | END | |
33828 | ||
33829 | <STATIC> | |
33830 | ||
33831 | import from TempA all; | |
33832 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
33833 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
33834 | ||
33835 | const BERPDU myValue := { | |
33836 | a := 1, | |
33837 | c := 3, | |
33838 | d := 4, | |
33839 | b := 2 } | |
33840 | ||
33841 | <TTCN_TC:EXEC> | |
33842 | ||
33843 | ||
33844 | ||
33845 | ||
33846 | if ((enc_DER_PDU(myValue) == '31120201016003020102A003020103E003020104'O)and(enc_CER_PDU(myValue) == '318002010160800201020000A0800201030000E08002010400000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
33847 | ||
33848 | <RESULT> | |
33849 | ||
33850 | Overall verdict: pass | |
33851 | ||
33852 | <END_TC> | |
33853 | ||
33854 | :exmp. | |
33855 | ||
33856 | .*---------------------------------------------------------------------* | |
33857 | :h3.CER + DER encoding of SET including untagged CHOICE (spec example) IMPLICIT TAGS | |
33858 | .*---------------------------------------------------------------------* | |
33859 | :xmp tab=0. | |
33860 | ||
33861 | <TC - CER + DER encoding of SET including untagged CHOICE (spec example) IMPLICIT TAGS> | |
33862 | ||
33863 | <STATIC:ASN> | |
33864 | ||
33865 | TempA | |
33866 | ||
33867 | DEFINITIONS | |
33868 | ||
33869 | IMPLICIT TAGS | |
33870 | ||
33871 | ::= | |
33872 | ||
33873 | BEGIN | |
33874 | ||
33875 | BERPDU ::= SET | |
33876 | { | |
33877 | a [3] INTEGER, | |
33878 | b [1] CHOICE | |
33879 | { | |
33880 | c [2] INTEGER, | |
33881 | d [4] INTEGER | |
33882 | }, | |
33883 | e CHOICE | |
33884 | { | |
33885 | f CHOICE | |
33886 | { | |
33887 | g [5] INTEGER, | |
33888 | h [6] INTEGER | |
33889 | }, | |
33890 | i CHOICE | |
33891 | { | |
33892 | ||
33893 | ||
33894 | j [0] INTEGER | |
33895 | ||
33896 | } | |
33897 | } | |
33898 | } | |
33899 | ||
33900 | ||
33901 | END | |
33902 | ||
33903 | <STATIC> | |
33904 | ||
33905 | import from TempA all; | |
33906 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
33907 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
33908 | ||
33909 | const BERPDU myValue := { | |
33910 | a := 1, | |
33911 | b := {c:= 2}, | |
33912 | e := { f := {g := 3 } } | |
33913 | } | |
33914 | ||
33915 | <TTCN_TC:EXEC> | |
33916 | ||
33917 | ||
33918 | ||
33919 | ||
33920 | if ((enc_DER_PDU(myValue) == '310BA103820102830101850103'O)and(enc_CER_PDU(myValue) == '3180850103A18082010200008301010000'O)) {setverdict(pass);} else {setverdict(fail);} | |
33921 | ||
33922 | <RESULT> | |
33923 | ||
33924 | Overall verdict: pass | |
33925 | ||
33926 | <END_TC> | |
33927 | ||
33928 | :exmp. | |
33929 | ||
33930 | .*---------------------------------------------------------------------* | |
33931 | :h3.CER + DER encoding of SET including untagged CHOICE (spec example) EXPLICIT TAGS | |
33932 | .*---------------------------------------------------------------------* | |
33933 | :xmp tab=0. | |
33934 | ||
33935 | <TC - CER + DER encoding of SET including untagged CHOICE (spec example) EXPLICIT TAGS> | |
33936 | ||
33937 | <STATIC:ASN> | |
33938 | ||
33939 | TempA | |
33940 | ||
33941 | DEFINITIONS | |
33942 | ||
33943 | EXPLICIT TAGS | |
33944 | ||
33945 | ::= | |
33946 | ||
33947 | BEGIN | |
33948 | ||
33949 | BERPDU ::= SET | |
33950 | { | |
33951 | a [3] INTEGER, | |
33952 | b [1] CHOICE | |
33953 | { | |
33954 | c [2] INTEGER, | |
33955 | d [4] INTEGER | |
33956 | }, | |
33957 | e CHOICE | |
33958 | { | |
33959 | f CHOICE | |
33960 | { | |
33961 | g [5] INTEGER, | |
33962 | h [6] INTEGER | |
33963 | }, | |
33964 | i CHOICE | |
33965 | { | |
33966 | ||
33967 | ||
33968 | j [0] INTEGER | |
33969 | ||
33970 | } | |
33971 | } | |
33972 | } | |
33973 | ||
33974 | ||
33975 | END | |
33976 | ||
33977 | <STATIC> | |
33978 | ||
33979 | import from TempA all; | |
33980 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
33981 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
33982 | ||
33983 | const BERPDU myValue := { | |
33984 | a := 1, | |
33985 | b := {c:= 2}, | |
33986 | e := { f := { g := 3 } } | |
33987 | } | |
33988 | ||
33989 | <TTCN_TC:EXEC> | |
33990 | ||
33991 | ||
33992 | ||
33993 | ||
33994 | if ((enc_DER_PDU(myValue) == '3111A105A203020102A303020101A503020103'O)and(enc_CER_PDU(myValue) == '3180A5800201030000A180A28002010200000000A38002010100000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
33995 | ||
33996 | <RESULT> | |
33997 | ||
33998 | Overall verdict: pass | |
33999 | ||
34000 | <END_TC> | |
34001 | ||
34002 | :exmp. | |
34003 | ||
34004 | .*---------------------------------------------------------------------* | |
34005 | :h3. DECODING DER , SET (EMPTY) | |
34006 | .*---------------------------------------------------------------------* | |
34007 | :xmp tab=0. | |
34008 | ||
34009 | <TC - DECODING DER , SET (EMPTY)> | |
34010 | ||
34011 | <STATIC:ASN> | |
34012 | ||
34013 | TempA | |
34014 | ||
34015 | DEFINITIONS ::= | |
34016 | BEGIN | |
34017 | BERPDU ::= SET | |
34018 | { | |
34019 | b BOOLEAN OPTIONAL, | |
34020 | c INTEGER OPTIONAL | |
34021 | } | |
34022 | ||
34023 | END | |
34024 | ||
34025 | <STATIC> | |
34026 | ||
34027 | import from TempA all; | |
34028 | ||
34029 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34030 | ||
34031 | ||
34032 | const BERPDU myValue := {b := omit, | |
34033 | c := omit } | |
34034 | ||
34035 | <TTCN_TC:EXEC> | |
34036 | ||
34037 | if (dec_BER_PDU('3100'O) == myValue) | |
34038 | ||
34039 | ||
34040 | ||
34041 | {setverdict(pass);} else {setverdict(fail);} | |
34042 | ||
34043 | ||
34044 | <RESULT> | |
34045 | ||
34046 | Overall verdict: pass | |
34047 | ||
34048 | <END_TC> | |
34049 | ||
34050 | :exmp. | |
34051 | ||
34052 | .*---------------------------------------------------------------------* | |
34053 | :h3. DECODING CER , SET (EMPTY) | |
34054 | .*---------------------------------------------------------------------* | |
34055 | :xmp tab=0. | |
34056 | ||
34057 | <TC - DECODING CER , SET (EMPTY)> | |
34058 | ||
34059 | <STATIC:ASN> | |
34060 | ||
34061 | TempA | |
34062 | ||
34063 | DEFINITIONS ::= | |
34064 | BEGIN | |
34065 | BERPDU ::= SET | |
34066 | { | |
34067 | b BOOLEAN OPTIONAL, | |
34068 | c INTEGER OPTIONAL | |
34069 | } | |
34070 | ||
34071 | END | |
34072 | ||
34073 | <STATIC> | |
34074 | ||
34075 | import from TempA all; | |
34076 | ||
34077 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34078 | ||
34079 | ||
34080 | const BERPDU myValue := {b := omit, | |
34081 | c := omit } | |
34082 | ||
34083 | <TTCN_TC:EXEC> | |
34084 | ||
34085 | if (dec_BER_PDU('31800000'O) == myValue) | |
34086 | ||
34087 | ||
34088 | ||
34089 | {setverdict(pass);} else {setverdict(fail);} | |
34090 | ||
34091 | ||
34092 | <RESULT> | |
34093 | ||
34094 | Overall verdict: pass | |
34095 | ||
34096 | <END_TC> | |
34097 | ||
34098 | :exmp. | |
34099 | ||
34100 | .*---------------------------------------------------------------------* | |
34101 | :h3.DECODING DER , SET (only one element is used) | |
34102 | .*---------------------------------------------------------------------* | |
34103 | :xmp tab=0. | |
34104 | ||
34105 | <TC - DECODING DER , SET (only one element is used)> | |
34106 | ||
34107 | <STATIC:ASN> | |
34108 | ||
34109 | TempA | |
34110 | ||
34111 | DEFINITIONS ::= | |
34112 | BEGIN | |
34113 | BERPDU ::= SET | |
34114 | { | |
34115 | b BOOLEAN OPTIONAL, | |
34116 | c INTEGER OPTIONAL | |
34117 | } | |
34118 | ||
34119 | ||
34120 | END | |
34121 | ||
34122 | <STATIC> | |
34123 | ||
34124 | import from TempA all; | |
34125 | ||
34126 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34127 | ||
34128 | ||
34129 | const BERPDU myValue := {b := true, | |
34130 | c := omit } | |
34131 | ||
34132 | <TTCN_TC:EXEC> | |
34133 | ||
34134 | if (dec_BER_PDU('31030101FF'O) == myValue) | |
34135 | ||
34136 | ||
34137 | ||
34138 | {setverdict(pass);} else {setverdict(fail);} | |
34139 | ||
34140 | ||
34141 | <RESULT> | |
34142 | ||
34143 | Overall verdict: pass | |
34144 | ||
34145 | <END_TC> | |
34146 | ||
34147 | :exmp. | |
34148 | ||
34149 | .*---------------------------------------------------------------------* | |
34150 | :h3.DECODING CER , SET (only one element is used) | |
34151 | .*---------------------------------------------------------------------* | |
34152 | :xmp tab=0. | |
34153 | ||
34154 | <TC - DECODING CER , SET (only one element is used)> | |
34155 | ||
34156 | <STATIC:ASN> | |
34157 | ||
34158 | TempA | |
34159 | ||
34160 | DEFINITIONS ::= | |
34161 | BEGIN | |
34162 | BERPDU ::= SET | |
34163 | { | |
34164 | b BOOLEAN OPTIONAL, | |
34165 | c INTEGER OPTIONAL | |
34166 | } | |
34167 | ||
34168 | ||
34169 | END | |
34170 | ||
34171 | <STATIC> | |
34172 | ||
34173 | import from TempA all; | |
34174 | ||
34175 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34176 | ||
34177 | ||
34178 | const BERPDU myValue := {b := true, | |
34179 | c := omit } | |
34180 | ||
34181 | <TTCN_TC:EXEC> | |
34182 | ||
34183 | if (dec_BER_PDU('31800101FF0000'O) == myValue) | |
34184 | ||
34185 | ||
34186 | ||
34187 | {setverdict(pass);} else {setverdict(fail);} | |
34188 | ||
34189 | ||
34190 | <RESULT> | |
34191 | ||
34192 | Overall verdict: pass | |
34193 | ||
34194 | <END_TC> | |
34195 | ||
34196 | :exmp. | |
34197 | ||
34198 | .*---------------------------------------------------------------------* | |
34199 | :h3. DECODING DER , SET (both elements are used) | |
34200 | .*---------------------------------------------------------------------* | |
34201 | :xmp tab=0. | |
34202 | ||
34203 | <TC - DECODING DER , SET (both elements are used)> | |
34204 | ||
34205 | <STATIC:ASN> | |
34206 | ||
34207 | TempA | |
34208 | ||
34209 | DEFINITIONS ::= | |
34210 | BEGIN | |
34211 | BERPDU ::= SET | |
34212 | { | |
34213 | b BOOLEAN OPTIONAL, | |
34214 | c INTEGER OPTIONAL | |
34215 | } | |
34216 | ||
34217 | ||
34218 | END | |
34219 | ||
34220 | <STATIC> | |
34221 | ||
34222 | import from TempA all; | |
34223 | ||
34224 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34225 | ||
34226 | ||
34227 | const BERPDU myValue := {b := true, | |
34228 | c := 5 } | |
34229 | ||
34230 | ||
34231 | <TTCN_TC:EXEC> | |
34232 | ||
34233 | if (dec_BER_PDU('31060101FF020105'O) == myValue) | |
34234 | ||
34235 | ||
34236 | ||
34237 | {setverdict(pass);} else {setverdict(fail);} | |
34238 | ||
34239 | ||
34240 | <RESULT> | |
34241 | ||
34242 | Overall verdict: pass | |
34243 | ||
34244 | <END_TC> | |
34245 | ||
34246 | :exmp. | |
34247 | ||
34248 | .*---------------------------------------------------------------------* | |
34249 | :h3. DECODING CER , SET (both elements are used) | |
34250 | .*---------------------------------------------------------------------* | |
34251 | :xmp tab=0. | |
34252 | ||
34253 | <TC - DECODING CER , SET (both elements are used)> | |
34254 | ||
34255 | <STATIC:ASN> | |
34256 | ||
34257 | TempA | |
34258 | ||
34259 | DEFINITIONS ::= | |
34260 | BEGIN | |
34261 | BERPDU ::= SET | |
34262 | { | |
34263 | b BOOLEAN OPTIONAL, | |
34264 | c INTEGER OPTIONAL | |
34265 | } | |
34266 | ||
34267 | ||
34268 | END | |
34269 | ||
34270 | <STATIC> | |
34271 | ||
34272 | import from TempA all; | |
34273 | ||
34274 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34275 | ||
34276 | ||
34277 | const BERPDU myValue := {b := true, | |
34278 | c := 5 } | |
34279 | ||
34280 | ||
34281 | <TTCN_TC:EXEC> | |
34282 | ||
34283 | if (dec_BER_PDU('31800101FF0201050000'O) == myValue) | |
34284 | ||
34285 | ||
34286 | ||
34287 | {setverdict(pass);} else {setverdict(fail);} | |
34288 | ||
34289 | ||
34290 | <RESULT> | |
34291 | ||
34292 | Overall verdict: pass | |
34293 | ||
34294 | <END_TC> | |
34295 | ||
34296 | :exmp. | |
34297 | ||
34298 | .*---------------------------------------------------------------------* | |
34299 | :h3. DECODING ,different order , SET (both elements are used) | |
34300 | .*---------------------------------------------------------------------* | |
34301 | :xmp tab=0. | |
34302 | ||
34303 | <TC - DECODING ,different order , SET (both elements are used)> | |
34304 | ||
34305 | <STATIC:ASN> | |
34306 | ||
34307 | TempA | |
34308 | ||
34309 | DEFINITIONS ::= | |
34310 | BEGIN | |
34311 | BERPDU ::= SET | |
34312 | { | |
34313 | ||
34314 | c INTEGER OPTIONAL, | |
34315 | b BOOLEAN OPTIONAL | |
34316 | } | |
34317 | ||
34318 | ||
34319 | END | |
34320 | ||
34321 | <STATIC> | |
34322 | ||
34323 | import from TempA all; | |
34324 | ||
34325 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34326 | ||
34327 | ||
34328 | const BERPDU myValue := {b := true, | |
34329 | c := 5 } | |
34330 | ||
34331 | ||
34332 | <TTCN_TC:EXEC> | |
34333 | ||
34334 | if (dec_BER_PDU('31060201050101FF'O) == myValue) | |
34335 | ||
34336 | ||
34337 | ||
34338 | {setverdict(pass);} else {setverdict(fail);} | |
34339 | ||
34340 | ||
34341 | <RESULT> | |
34342 | ||
34343 | Overall verdict: pass | |
34344 | ||
34345 | <END_TC> | |
34346 | ||
34347 | :exmp. | |
34348 | ||
34349 | .*---------------------------------------------------------------------* | |
34350 | :h3. DECODING , different order, SET (both elements are used) | |
34351 | .*---------------------------------------------------------------------* | |
34352 | :xmp tab=0. | |
34353 | ||
34354 | <TC - DECODING , different order, SET (both elements are used)> | |
34355 | ||
34356 | <STATIC:ASN> | |
34357 | ||
34358 | TempA | |
34359 | ||
34360 | DEFINITIONS ::= | |
34361 | BEGIN | |
34362 | BERPDU ::= SET | |
34363 | { | |
34364 | ||
34365 | c INTEGER OPTIONAL, | |
34366 | b BOOLEAN OPTIONAL | |
34367 | } | |
34368 | ||
34369 | ||
34370 | END | |
34371 | ||
34372 | <STATIC> | |
34373 | ||
34374 | import from TempA all; | |
34375 | ||
34376 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34377 | ||
34378 | ||
34379 | const BERPDU myValue := { | |
34380 | c := 5, | |
34381 | b := true } | |
34382 | ||
34383 | ||
34384 | <TTCN_TC:EXEC> | |
34385 | ||
34386 | if (dec_BER_PDU('31800201050101FF0000'O) == myValue) | |
34387 | ||
34388 | ||
34389 | ||
34390 | {setverdict(pass);} else {setverdict(fail);} | |
34391 | ||
34392 | ||
34393 | <RESULT> | |
34394 | ||
34395 | Overall verdict: pass | |
34396 | ||
34397 | <END_TC> | |
34398 | ||
34399 | :exmp. | |
34400 | ||
34401 | .*---------------------------------------------------------------------* | |
34402 | :h3. DECODING DER , SET (one element is equal to Default) | |
34403 | .*---------------------------------------------------------------------* | |
34404 | :xmp tab=0. | |
34405 | ||
34406 | <TC - DECODING DER , SET (one element is equal to Default)> | |
34407 | ||
34408 | <STATIC:ASN> | |
34409 | ||
34410 | TempA | |
34411 | ||
34412 | DEFINITIONS ::= | |
34413 | BEGIN | |
34414 | BERPDU ::= SET | |
34415 | { | |
34416 | b BOOLEAN DEFAULT TRUE, | |
34417 | c INTEGER OPTIONAL | |
34418 | } | |
34419 | ||
34420 | END | |
34421 | ||
34422 | <STATIC> | |
34423 | ||
34424 | import from TempA all; | |
34425 | ||
34426 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34427 | ||
34428 | ||
34429 | const BERPDU myValue := {b := true, | |
34430 | c := 5 } | |
34431 | <TTCN_TC:EXEC> | |
34432 | ||
34433 | if (dec_BER_PDU('3103020105'O) == myValue) | |
34434 | ||
34435 | ||
34436 | ||
34437 | {setverdict(pass);} else {setverdict(fail);} | |
34438 | ||
34439 | ||
34440 | <RESULT> | |
34441 | ||
34442 | Overall verdict: pass | |
34443 | ||
34444 | <END_TC> | |
34445 | ||
34446 | :exmp. | |
34447 | ||
34448 | .*---------------------------------------------------------------------* | |
34449 | :h3. DECODING CER, SET (one element is equal to Default) | |
34450 | .*---------------------------------------------------------------------* | |
34451 | :xmp tab=0. | |
34452 | ||
34453 | <TC - DECODING CER, SET (one element is equal to Default)> | |
34454 | ||
34455 | <STATIC:ASN> | |
34456 | ||
34457 | TempA | |
34458 | ||
34459 | DEFINITIONS ::= | |
34460 | BEGIN | |
34461 | BERPDU ::= SET | |
34462 | { | |
34463 | b BOOLEAN DEFAULT TRUE, | |
34464 | c INTEGER OPTIONAL | |
34465 | } | |
34466 | ||
34467 | END | |
34468 | ||
34469 | <STATIC> | |
34470 | ||
34471 | import from TempA all; | |
34472 | ||
34473 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34474 | ||
34475 | ||
34476 | const BERPDU myValue := {b := true, | |
34477 | c := 5 } | |
34478 | <TTCN_TC:EXEC> | |
34479 | ||
34480 | if (dec_BER_PDU('31800201050000'O) == myValue) | |
34481 | ||
34482 | ||
34483 | ||
34484 | {setverdict(pass);} else {setverdict(fail);} | |
34485 | ||
34486 | ||
34487 | <RESULT> | |
34488 | ||
34489 | Overall verdict: pass | |
34490 | ||
34491 | <END_TC> | |
34492 | ||
34493 | :exmp. | |
34494 | ||
34495 | .*---------------------------------------------------------------------* | |
34496 | :h3. DECODING, default included , SET (one element is equal to Default) | |
34497 | .*---------------------------------------------------------------------* | |
34498 | :xmp tab=0. | |
34499 | ||
34500 | <TC - DECODING, default included , SET (one element is equal to Default)> | |
34501 | ||
34502 | <STATIC:ASN> | |
34503 | ||
34504 | TempA | |
34505 | ||
34506 | DEFINITIONS ::= | |
34507 | BEGIN | |
34508 | BERPDU ::= SET | |
34509 | { | |
34510 | b BOOLEAN DEFAULT TRUE, | |
34511 | c INTEGER OPTIONAL | |
34512 | } | |
34513 | ||
34514 | END | |
34515 | ||
34516 | <STATIC> | |
34517 | ||
34518 | import from TempA all; | |
34519 | ||
34520 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34521 | ||
34522 | ||
34523 | const BERPDU myValue := {b := true, | |
34524 | c := 5 } | |
34525 | <TTCN_TC:EXEC> | |
34526 | ||
34527 | if (dec_BER_PDU('31060201050101FF'O) == myValue) | |
34528 | ||
34529 | ||
34530 | ||
34531 | {setverdict(pass);} else {setverdict(fail);} | |
34532 | ||
34533 | ||
34534 | <RESULT> | |
34535 | ||
34536 | Overall verdict: pass | |
34537 | ||
34538 | <END_TC> | |
34539 | ||
34540 | :exmp. | |
34541 | ||
34542 | .*---------------------------------------------------------------------* | |
34543 | :h3. DECODING , default included, SET (one element is equal to Default) | |
34544 | .*---------------------------------------------------------------------* | |
34545 | :xmp tab=0. | |
34546 | ||
34547 | <TC - DECODING , default included, SET (one element is equal to Default)> | |
34548 | ||
34549 | <STATIC:ASN> | |
34550 | ||
34551 | TempA | |
34552 | ||
34553 | DEFINITIONS ::= | |
34554 | BEGIN | |
34555 | BERPDU ::= SET | |
34556 | { | |
34557 | b BOOLEAN DEFAULT TRUE, | |
34558 | c INTEGER OPTIONAL | |
34559 | } | |
34560 | ||
34561 | END | |
34562 | ||
34563 | <STATIC> | |
34564 | ||
34565 | import from TempA all; | |
34566 | ||
34567 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34568 | ||
34569 | ||
34570 | const BERPDU myValue := {b := true, | |
34571 | c := 5 } | |
34572 | <TTCN_TC:EXEC> | |
34573 | ||
34574 | if (dec_BER_PDU('31800101FF0201050000'O) == myValue) | |
34575 | ||
34576 | ||
34577 | ||
34578 | {setverdict(pass);} else {setverdict(fail);} | |
34579 | ||
34580 | ||
34581 | <RESULT> | |
34582 | ||
34583 | Overall verdict: pass | |
34584 | ||
34585 | <END_TC> | |
34586 | ||
34587 | :exmp. | |
34588 | ||
34589 | .*---------------------------------------------------------------------* | |
34590 | :h3. DECODING DER , SET (one element is not equal to Default) | |
34591 | .*---------------------------------------------------------------------* | |
34592 | :xmp tab=0. | |
34593 | ||
34594 | <TC - DECODING DER , SET (one element is not equal to Default)> | |
34595 | ||
34596 | <STATIC:ASN> | |
34597 | ||
34598 | TempA | |
34599 | ||
34600 | DEFINITIONS ::= | |
34601 | BEGIN | |
34602 | ||
34603 | BERPDU ::= SET | |
34604 | { | |
34605 | b BOOLEAN DEFAULT TRUE, | |
34606 | c INTEGER OPTIONAL | |
34607 | } | |
34608 | ||
34609 | ||
34610 | END | |
34611 | ||
34612 | <STATIC> | |
34613 | ||
34614 | import from TempA all; | |
34615 | ||
34616 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34617 | ||
34618 | ||
34619 | const BERPDU myValue := {b := false, | |
34620 | c := 5 } | |
34621 | <TTCN_TC:EXEC> | |
34622 | ||
34623 | if (dec_BER_PDU('3106010100020105'O) == myValue) | |
34624 | ||
34625 | ||
34626 | ||
34627 | {setverdict(pass);} else {setverdict(fail);} | |
34628 | ||
34629 | ||
34630 | <RESULT> | |
34631 | ||
34632 | Overall verdict: pass | |
34633 | ||
34634 | <END_TC> | |
34635 | ||
34636 | :exmp. | |
34637 | ||
34638 | .*---------------------------------------------------------------------* | |
34639 | :h3. DECODING CER , SET (one element is not equal to Default) | |
34640 | .*---------------------------------------------------------------------* | |
34641 | :xmp tab=0. | |
34642 | ||
34643 | <TC - DECODING CER , SET (one element is not equal to Default)> | |
34644 | ||
34645 | <STATIC:ASN> | |
34646 | ||
34647 | TempA | |
34648 | ||
34649 | DEFINITIONS ::= | |
34650 | BEGIN | |
34651 | ||
34652 | BERPDU ::= SET | |
34653 | { | |
34654 | b BOOLEAN DEFAULT TRUE, | |
34655 | c INTEGER OPTIONAL | |
34656 | } | |
34657 | ||
34658 | ||
34659 | END | |
34660 | ||
34661 | <STATIC> | |
34662 | ||
34663 | import from TempA all; | |
34664 | ||
34665 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34666 | ||
34667 | ||
34668 | const BERPDU myValue := {b := false, | |
34669 | c := 5 } | |
34670 | <TTCN_TC:EXEC> | |
34671 | ||
34672 | if (dec_BER_PDU('31800101000201050000'O) == myValue) | |
34673 | ||
34674 | ||
34675 | ||
34676 | {setverdict(pass);} else {setverdict(fail);} | |
34677 | ||
34678 | ||
34679 | <RESULT> | |
34680 | ||
34681 | Overall verdict: pass | |
34682 | ||
34683 | <END_TC> | |
34684 | ||
34685 | :exmp. | |
34686 | ||
34687 | .*---------------------------------------------------------------------* | |
34688 | :h3. DECODING, reverse order , SET (one element is not equal to Default) | |
34689 | .*---------------------------------------------------------------------* | |
34690 | :xmp tab=0. | |
34691 | ||
34692 | <TC - DECODING, reverse order , SET (one element is not equal to Default)> | |
34693 | ||
34694 | <STATIC:ASN> | |
34695 | ||
34696 | TempA | |
34697 | ||
34698 | DEFINITIONS ::= | |
34699 | BEGIN | |
34700 | ||
34701 | BERPDU ::= SET | |
34702 | { | |
34703 | b BOOLEAN DEFAULT TRUE, | |
34704 | c INTEGER OPTIONAL | |
34705 | } | |
34706 | ||
34707 | ||
34708 | END | |
34709 | ||
34710 | <STATIC> | |
34711 | ||
34712 | import from TempA all; | |
34713 | ||
34714 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34715 | ||
34716 | ||
34717 | const BERPDU myValue := {b := false, | |
34718 | c := 5 } | |
34719 | <TTCN_TC:EXEC> | |
34720 | ||
34721 | if (dec_BER_PDU('3106020105010100'O) == myValue) | |
34722 | ||
34723 | ||
34724 | ||
34725 | {setverdict(pass);} else {setverdict(fail);} | |
34726 | ||
34727 | ||
34728 | <RESULT> | |
34729 | ||
34730 | Overall verdict: pass | |
34731 | ||
34732 | <END_TC> | |
34733 | ||
34734 | :exmp. | |
34735 | ||
34736 | .*---------------------------------------------------------------------* | |
34737 | :h3. DECODING ,reverse order , SET (one element is not equal to Default) | |
34738 | .*---------------------------------------------------------------------* | |
34739 | :xmp tab=0. | |
34740 | ||
34741 | <TC - DECODING ,reverse order , SET (one element is not equal to Default)> | |
34742 | ||
34743 | <STATIC:ASN> | |
34744 | ||
34745 | TempA | |
34746 | ||
34747 | DEFINITIONS ::= | |
34748 | BEGIN | |
34749 | ||
34750 | BERPDU ::= SET | |
34751 | { | |
34752 | b BOOLEAN DEFAULT TRUE, | |
34753 | c INTEGER OPTIONAL | |
34754 | } | |
34755 | ||
34756 | ||
34757 | END | |
34758 | ||
34759 | <STATIC> | |
34760 | ||
34761 | import from TempA all; | |
34762 | ||
34763 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34764 | ||
34765 | ||
34766 | const BERPDU myValue := {b := false, | |
34767 | c := 5 } | |
34768 | <TTCN_TC:EXEC> | |
34769 | ||
34770 | if (dec_BER_PDU('31800201050101000000'O) == myValue) | |
34771 | ||
34772 | ||
34773 | ||
34774 | {setverdict(pass);} else {setverdict(fail);} | |
34775 | ||
34776 | ||
34777 | <RESULT> | |
34778 | ||
34779 | Overall verdict: pass | |
34780 | ||
34781 | <END_TC> | |
34782 | ||
34783 | :exmp. | |
34784 | ||
34785 | .*---------------------------------------------------------------------* | |
34786 | :h3. DECODING DER , SET (EMPTY), AUTOMATIC TAGGING | |
34787 | .*---------------------------------------------------------------------* | |
34788 | :xmp tab=0. | |
34789 | ||
34790 | <TC - DECODING DER , SET (EMPTY), AUTOMATIC TAGGING> | |
34791 | ||
34792 | <STATIC:ASN> | |
34793 | ||
34794 | TempA | |
34795 | ||
34796 | DEFINITIONS | |
34797 | ||
34798 | AUTOMATIC TAGS | |
34799 | ||
34800 | ||
34801 | ::= | |
34802 | ||
34803 | BEGIN | |
34804 | ||
34805 | BERPDU ::= SET | |
34806 | { | |
34807 | b BOOLEAN OPTIONAL, | |
34808 | c INTEGER OPTIONAL | |
34809 | } | |
34810 | ||
34811 | ||
34812 | END | |
34813 | ||
34814 | <STATIC> | |
34815 | ||
34816 | import from TempA all; | |
34817 | ||
34818 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34819 | ||
34820 | ||
34821 | const BERPDU myValue := {b := omit, | |
34822 | c := omit } | |
34823 | ||
34824 | <TTCN_TC:EXEC> | |
34825 | ||
34826 | if (dec_BER_PDU('3100'O) == myValue) | |
34827 | ||
34828 | ||
34829 | ||
34830 | {setverdict(pass);} else {setverdict(fail);} | |
34831 | ||
34832 | ||
34833 | <RESULT> | |
34834 | ||
34835 | Overall verdict: pass | |
34836 | ||
34837 | <END_TC> | |
34838 | ||
34839 | :exmp. | |
34840 | ||
34841 | .*---------------------------------------------------------------------* | |
34842 | :h3. DECODING CER , SET (EMPTY), AUTOMATIC TAGGING | |
34843 | .*---------------------------------------------------------------------* | |
34844 | :xmp tab=0. | |
34845 | ||
34846 | <TC - DECODING CER , SET (EMPTY), AUTOMATIC TAGGING> | |
34847 | ||
34848 | <STATIC:ASN> | |
34849 | ||
34850 | TempA | |
34851 | ||
34852 | DEFINITIONS | |
34853 | ||
34854 | AUTOMATIC TAGS | |
34855 | ||
34856 | ||
34857 | ::= | |
34858 | ||
34859 | BEGIN | |
34860 | ||
34861 | BERPDU ::= SET | |
34862 | { | |
34863 | b BOOLEAN OPTIONAL, | |
34864 | c INTEGER OPTIONAL | |
34865 | } | |
34866 | ||
34867 | ||
34868 | END | |
34869 | ||
34870 | <STATIC> | |
34871 | ||
34872 | import from TempA all; | |
34873 | ||
34874 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34875 | ||
34876 | ||
34877 | const BERPDU myValue := {b := omit, | |
34878 | c := omit } | |
34879 | ||
34880 | <TTCN_TC:EXEC> | |
34881 | ||
34882 | if (dec_BER_PDU('31800000'O) == myValue) | |
34883 | ||
34884 | ||
34885 | ||
34886 | {setverdict(pass);} else {setverdict(fail);} | |
34887 | ||
34888 | ||
34889 | <RESULT> | |
34890 | ||
34891 | Overall verdict: pass | |
34892 | ||
34893 | <END_TC> | |
34894 | ||
34895 | :exmp. | |
34896 | ||
34897 | .*---------------------------------------------------------------------* | |
34898 | :h3. DECODING DER , SET (only one element is used) AUTOMATIC TAGGING | |
34899 | .*---------------------------------------------------------------------* | |
34900 | :xmp tab=0. | |
34901 | ||
34902 | <TC - DECODING DER , SET (only one element is used) AUTOMATIC TAGGING> | |
34903 | ||
34904 | <STATIC:ASN> | |
34905 | ||
34906 | TempA | |
34907 | ||
34908 | DEFINITIONS | |
34909 | ||
34910 | AUTOMATIC TAGS | |
34911 | ||
34912 | ||
34913 | ::= | |
34914 | ||
34915 | BEGIN | |
34916 | ||
34917 | ||
34918 | BERPDU ::= SET | |
34919 | { | |
34920 | b BOOLEAN OPTIONAL, | |
34921 | c INTEGER OPTIONAL | |
34922 | } | |
34923 | ||
34924 | ||
34925 | END | |
34926 | ||
34927 | <STATIC> | |
34928 | ||
34929 | import from TempA all; | |
34930 | ||
34931 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34932 | ||
34933 | ||
34934 | const BERPDU myValue := {b := true, | |
34935 | c := omit } | |
34936 | ||
34937 | <TTCN_TC:EXEC> | |
34938 | ||
34939 | if (dec_BER_PDU('31038001FF'O) == myValue) | |
34940 | ||
34941 | ||
34942 | ||
34943 | {setverdict(pass);} else {setverdict(fail);} | |
34944 | ||
34945 | ||
34946 | <RESULT> | |
34947 | ||
34948 | Overall verdict: pass | |
34949 | ||
34950 | <END_TC> | |
34951 | ||
34952 | :exmp. | |
34953 | ||
34954 | .*---------------------------------------------------------------------* | |
34955 | :h3. DECODING CER , SET (only one element is used) AUTOMATIC TAGGING | |
34956 | .*---------------------------------------------------------------------* | |
34957 | :xmp tab=0. | |
34958 | ||
34959 | <TC - DECODING CER , SET (only one element is used) AUTOMATIC TAGGING> | |
34960 | ||
34961 | <STATIC:ASN> | |
34962 | ||
34963 | TempA | |
34964 | ||
34965 | DEFINITIONS | |
34966 | ||
34967 | AUTOMATIC TAGS | |
34968 | ||
34969 | ||
34970 | ::= | |
34971 | ||
34972 | BEGIN | |
34973 | ||
34974 | ||
34975 | BERPDU ::= SET | |
34976 | { | |
34977 | b BOOLEAN OPTIONAL, | |
34978 | c INTEGER OPTIONAL | |
34979 | } | |
34980 | ||
34981 | ||
34982 | END | |
34983 | ||
34984 | <STATIC> | |
34985 | ||
34986 | import from TempA all; | |
34987 | ||
34988 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
34989 | ||
34990 | ||
34991 | const BERPDU myValue := {b := true, | |
34992 | c := omit } | |
34993 | ||
34994 | <TTCN_TC:EXEC> | |
34995 | ||
34996 | if (dec_BER_PDU('31808001FF0000'O) == myValue) | |
34997 | ||
34998 | ||
34999 | ||
35000 | {setverdict(pass);} else {setverdict(fail);} | |
35001 | ||
35002 | ||
35003 | <RESULT> | |
35004 | ||
35005 | Overall verdict: pass | |
35006 | ||
35007 | <END_TC> | |
35008 | ||
35009 | :exmp. | |
35010 | ||
35011 | .*---------------------------------------------------------------------* | |
35012 | :h3. DECODING DER , SET (both elements are used) AUTOMATIC TAGGING | |
35013 | .*---------------------------------------------------------------------* | |
35014 | :xmp tab=0. | |
35015 | ||
35016 | <TC - DECODING DER , SET (both elements are used) AUTOMATIC TAGGING> | |
35017 | ||
35018 | <STATIC:ASN> | |
35019 | ||
35020 | TempA | |
35021 | ||
35022 | DEFINITIONS | |
35023 | ||
35024 | AUTOMATIC TAGS | |
35025 | ||
35026 | ||
35027 | ::= | |
35028 | ||
35029 | BEGIN | |
35030 | ||
35031 | ||
35032 | BERPDU ::= SET | |
35033 | { | |
35034 | b BOOLEAN OPTIONAL, | |
35035 | c INTEGER OPTIONAL | |
35036 | } | |
35037 | ||
35038 | ||
35039 | ||
35040 | END | |
35041 | ||
35042 | <STATIC> | |
35043 | ||
35044 | import from TempA all; | |
35045 | ||
35046 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35047 | ||
35048 | ||
35049 | const BERPDU myValue := {b := true, | |
35050 | c := 5 } | |
35051 | ||
35052 | <TTCN_TC:EXEC> | |
35053 | ||
35054 | if (dec_BER_PDU('31068001FF810105'O) == myValue) | |
35055 | ||
35056 | ||
35057 | ||
35058 | {setverdict(pass);} else {setverdict(fail);} | |
35059 | ||
35060 | ||
35061 | <RESULT> | |
35062 | ||
35063 | Overall verdict: pass | |
35064 | ||
35065 | <END_TC> | |
35066 | ||
35067 | :exmp. | |
35068 | ||
35069 | .*---------------------------------------------------------------------* | |
35070 | :h3. DECODING CER , SET (both elements are used) AUTOMATIC TAGGING | |
35071 | .*---------------------------------------------------------------------* | |
35072 | :xmp tab=0. | |
35073 | ||
35074 | <TC - DECODING CER , SET (both elements are used) AUTOMATIC TAGGING> | |
35075 | ||
35076 | <STATIC:ASN> | |
35077 | ||
35078 | TempA | |
35079 | ||
35080 | DEFINITIONS | |
35081 | ||
35082 | AUTOMATIC TAGS | |
35083 | ||
35084 | ||
35085 | ::= | |
35086 | ||
35087 | BEGIN | |
35088 | ||
35089 | ||
35090 | BERPDU ::= SET | |
35091 | { | |
35092 | b BOOLEAN OPTIONAL, | |
35093 | c INTEGER OPTIONAL | |
35094 | } | |
35095 | ||
35096 | ||
35097 | ||
35098 | END | |
35099 | ||
35100 | <STATIC> | |
35101 | ||
35102 | import from TempA all; | |
35103 | ||
35104 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35105 | ||
35106 | ||
35107 | const BERPDU myValue := {b := true, | |
35108 | c := 5 } | |
35109 | ||
35110 | <TTCN_TC:EXEC> | |
35111 | ||
35112 | if (dec_BER_PDU('31808001FF8101050000'O) == myValue) | |
35113 | ||
35114 | ||
35115 | ||
35116 | {setverdict(pass);} else {setverdict(fail);} | |
35117 | ||
35118 | ||
35119 | <RESULT> | |
35120 | ||
35121 | Overall verdict: pass | |
35122 | ||
35123 | <END_TC> | |
35124 | ||
35125 | :exmp. | |
35126 | ||
35127 | .*---------------------------------------------------------------------* | |
35128 | :h3. DECODING ,reverse order , SET (both elements are used) AUTOMATIC TAGGING | |
35129 | .*---------------------------------------------------------------------* | |
35130 | :xmp tab=0. | |
35131 | ||
35132 | <TC - DECODING ,reverse order , SET (both elements are used) AUTOMATIC TAGGING> | |
35133 | ||
35134 | <STATIC:ASN> | |
35135 | ||
35136 | TempA | |
35137 | ||
35138 | DEFINITIONS | |
35139 | ||
35140 | AUTOMATIC TAGS | |
35141 | ||
35142 | ||
35143 | ::= | |
35144 | ||
35145 | BEGIN | |
35146 | ||
35147 | ||
35148 | BERPDU ::= SET | |
35149 | { | |
35150 | b BOOLEAN OPTIONAL, | |
35151 | c INTEGER OPTIONAL | |
35152 | } | |
35153 | ||
35154 | ||
35155 | ||
35156 | END | |
35157 | ||
35158 | <STATIC> | |
35159 | ||
35160 | import from TempA all; | |
35161 | ||
35162 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35163 | ||
35164 | ||
35165 | const BERPDU myValue := {b := true, | |
35166 | c := 5 } | |
35167 | ||
35168 | <TTCN_TC:EXEC> | |
35169 | ||
35170 | if (dec_BER_PDU('31068101058001FF'O) == myValue) | |
35171 | ||
35172 | ||
35173 | ||
35174 | {setverdict(pass);} else {setverdict(fail);} | |
35175 | ||
35176 | ||
35177 | <RESULT> | |
35178 | ||
35179 | Overall verdict: pass | |
35180 | ||
35181 | <END_TC> | |
35182 | ||
35183 | :exmp. | |
35184 | ||
35185 | .*---------------------------------------------------------------------* | |
35186 | :h3. DECODING, reverse order , SET (both elements are used) AUTOMATIC TAGGING | |
35187 | .*---------------------------------------------------------------------* | |
35188 | :xmp tab=0. | |
35189 | ||
35190 | <TC - DECODING, reverse order , SET (both elements are used) AUTOMATIC TAGGING> | |
35191 | ||
35192 | <STATIC:ASN> | |
35193 | ||
35194 | TempA | |
35195 | ||
35196 | DEFINITIONS | |
35197 | ||
35198 | AUTOMATIC TAGS | |
35199 | ||
35200 | ||
35201 | ::= | |
35202 | ||
35203 | BEGIN | |
35204 | ||
35205 | ||
35206 | BERPDU ::= SET | |
35207 | { | |
35208 | b BOOLEAN OPTIONAL, | |
35209 | c INTEGER OPTIONAL | |
35210 | } | |
35211 | ||
35212 | ||
35213 | ||
35214 | END | |
35215 | ||
35216 | <STATIC> | |
35217 | ||
35218 | import from TempA all; | |
35219 | ||
35220 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35221 | ||
35222 | ||
35223 | const BERPDU myValue := {b := true, | |
35224 | c := 5 } | |
35225 | ||
35226 | <TTCN_TC:EXEC> | |
35227 | ||
35228 | if (dec_BER_PDU('31808101058001FF0000'O) == myValue) | |
35229 | ||
35230 | ||
35231 | ||
35232 | {setverdict(pass);} else {setverdict(fail);} | |
35233 | ||
35234 | ||
35235 | <RESULT> | |
35236 | ||
35237 | Overall verdict: pass | |
35238 | ||
35239 | <END_TC> | |
35240 | ||
35241 | :exmp. | |
35242 | ||
35243 | .*---------------------------------------------------------------------* | |
35244 | :h3. DECODING DER , SET (one element is equal to Default) AUTOMATIC TAGGING | |
35245 | .*---------------------------------------------------------------------* | |
35246 | :xmp tab=0. | |
35247 | ||
35248 | <TC - DECODING DER , SET (one element is equal to Default) AUTOMATIC TAGGING > | |
35249 | ||
35250 | <STATIC:ASN> | |
35251 | ||
35252 | TempA | |
35253 | ||
35254 | DEFINITIONS | |
35255 | ||
35256 | AUTOMATIC TAGS | |
35257 | ||
35258 | ||
35259 | ::= | |
35260 | ||
35261 | BEGIN | |
35262 | ||
35263 | ||
35264 | BERPDU ::= SET | |
35265 | { | |
35266 | b BOOLEAN DEFAULT TRUE, | |
35267 | c INTEGER OPTIONAL | |
35268 | } | |
35269 | ||
35270 | ||
35271 | ||
35272 | END | |
35273 | ||
35274 | <STATIC> | |
35275 | ||
35276 | import from TempA all; | |
35277 | ||
35278 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35279 | ||
35280 | ||
35281 | const BERPDU myValue := {b := true, | |
35282 | c := 5 } | |
35283 | ||
35284 | <TTCN_TC:EXEC> | |
35285 | ||
35286 | if (dec_BER_PDU('3103810105'O) == myValue) | |
35287 | ||
35288 | ||
35289 | ||
35290 | {setverdict(pass);} else {setverdict(fail);} | |
35291 | ||
35292 | ||
35293 | <RESULT> | |
35294 | ||
35295 | Overall verdict: pass | |
35296 | ||
35297 | <END_TC> | |
35298 | ||
35299 | :exmp. | |
35300 | ||
35301 | .*---------------------------------------------------------------------* | |
35302 | :h3. DECODING CER , SET (one element is equal to Default) AUTOMATIC TAGGING | |
35303 | .*---------------------------------------------------------------------* | |
35304 | :xmp tab=0. | |
35305 | ||
35306 | <TC - DECODING CER , SET (one element is equal to Default) AUTOMATIC TAGGING > | |
35307 | ||
35308 | <STATIC:ASN> | |
35309 | ||
35310 | TempA | |
35311 | ||
35312 | DEFINITIONS | |
35313 | ||
35314 | AUTOMATIC TAGS | |
35315 | ||
35316 | ||
35317 | ::= | |
35318 | ||
35319 | BEGIN | |
35320 | ||
35321 | ||
35322 | BERPDU ::= SET | |
35323 | { | |
35324 | b BOOLEAN DEFAULT TRUE, | |
35325 | c INTEGER OPTIONAL | |
35326 | } | |
35327 | ||
35328 | ||
35329 | ||
35330 | END | |
35331 | ||
35332 | <STATIC> | |
35333 | ||
35334 | import from TempA all; | |
35335 | ||
35336 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35337 | ||
35338 | ||
35339 | const BERPDU myValue := {b := true, | |
35340 | c := 5 } | |
35341 | ||
35342 | <TTCN_TC:EXEC> | |
35343 | ||
35344 | if (dec_BER_PDU('31808101050000'O) == myValue) | |
35345 | ||
35346 | ||
35347 | ||
35348 | {setverdict(pass);} else {setverdict(fail);} | |
35349 | ||
35350 | ||
35351 | <RESULT> | |
35352 | ||
35353 | Overall verdict: pass | |
35354 | ||
35355 | <END_TC> | |
35356 | ||
35357 | :exmp. | |
35358 | ||
35359 | .*---------------------------------------------------------------------* | |
35360 | :h3. DECODING , default included , SET (one element is equal to Default) AUTOMATIC TAGGING | |
35361 | .*---------------------------------------------------------------------* | |
35362 | :xmp tab=0. | |
35363 | ||
35364 | <TC - DECODING , default included , SET (one element is equal to Default) AUTOMATIC TAGGING > | |
35365 | ||
35366 | <STATIC:ASN> | |
35367 | ||
35368 | TempA | |
35369 | ||
35370 | DEFINITIONS | |
35371 | ||
35372 | AUTOMATIC TAGS | |
35373 | ||
35374 | ||
35375 | ::= | |
35376 | ||
35377 | BEGIN | |
35378 | ||
35379 | ||
35380 | BERPDU ::= SET | |
35381 | { | |
35382 | b BOOLEAN DEFAULT TRUE, | |
35383 | c INTEGER OPTIONAL | |
35384 | } | |
35385 | ||
35386 | ||
35387 | ||
35388 | END | |
35389 | ||
35390 | <STATIC> | |
35391 | ||
35392 | import from TempA all; | |
35393 | ||
35394 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35395 | ||
35396 | ||
35397 | const BERPDU myValue := {b := true, | |
35398 | c := 5 } | |
35399 | ||
35400 | <TTCN_TC:EXEC> | |
35401 | ||
35402 | if (dec_BER_PDU('31068001FF810105'O) == myValue) | |
35403 | ||
35404 | ||
35405 | ||
35406 | {setverdict(pass);} else {setverdict(fail);} | |
35407 | ||
35408 | ||
35409 | <RESULT> | |
35410 | ||
35411 | Overall verdict: pass | |
35412 | ||
35413 | <END_TC> | |
35414 | ||
35415 | :exmp. | |
35416 | ||
35417 | .*---------------------------------------------------------------------* | |
35418 | :h3. DECODING , default included, SET (one element is equal to Default) AUTOMATIC TAGGING | |
35419 | .*---------------------------------------------------------------------* | |
35420 | :xmp tab=0. | |
35421 | ||
35422 | <TC - DECODING , default included, SET (one element is equal to Default) AUTOMATIC TAGGING > | |
35423 | ||
35424 | <STATIC:ASN> | |
35425 | ||
35426 | TempA | |
35427 | ||
35428 | DEFINITIONS | |
35429 | ||
35430 | AUTOMATIC TAGS | |
35431 | ||
35432 | ||
35433 | ::= | |
35434 | ||
35435 | BEGIN | |
35436 | ||
35437 | ||
35438 | BERPDU ::= SET | |
35439 | { | |
35440 | b BOOLEAN DEFAULT TRUE, | |
35441 | c INTEGER OPTIONAL | |
35442 | } | |
35443 | ||
35444 | ||
35445 | ||
35446 | END | |
35447 | ||
35448 | <STATIC> | |
35449 | ||
35450 | import from TempA all; | |
35451 | ||
35452 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35453 | ||
35454 | ||
35455 | const BERPDU myValue := {b := true, | |
35456 | c := 5 } | |
35457 | ||
35458 | <TTCN_TC:EXEC> | |
35459 | ||
35460 | if (dec_BER_PDU('31808101058001FF0000'O) == myValue) | |
35461 | ||
35462 | ||
35463 | ||
35464 | {setverdict(pass);} else {setverdict(fail);} | |
35465 | ||
35466 | ||
35467 | <RESULT> | |
35468 | ||
35469 | Overall verdict: pass | |
35470 | ||
35471 | <END_TC> | |
35472 | ||
35473 | :exmp. | |
35474 | ||
35475 | .*---------------------------------------------------------------------* | |
35476 | :h3. DECODING DER ,SET (one element is not equal to Default) AUTOMATIC TAGGING | |
35477 | .*---------------------------------------------------------------------* | |
35478 | :xmp tab=0. | |
35479 | ||
35480 | <TC - DECODING DER ,SET (one element is not equal to Default) AUTOMATIC TAGGING> | |
35481 | ||
35482 | <STATIC:ASN> | |
35483 | ||
35484 | TempA | |
35485 | ||
35486 | DEFINITIONS | |
35487 | ||
35488 | AUTOMATIC TAGS | |
35489 | ||
35490 | ||
35491 | ::= | |
35492 | ||
35493 | BEGIN | |
35494 | ||
35495 | ||
35496 | BERPDU ::= SET | |
35497 | { | |
35498 | b BOOLEAN DEFAULT TRUE, | |
35499 | c INTEGER OPTIONAL | |
35500 | } | |
35501 | ||
35502 | ||
35503 | ||
35504 | END | |
35505 | ||
35506 | <STATIC> | |
35507 | ||
35508 | import from TempA all; | |
35509 | ||
35510 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35511 | ||
35512 | ||
35513 | const BERPDU myValue := {b := false, | |
35514 | c := 5 } | |
35515 | ||
35516 | <TTCN_TC:EXEC> | |
35517 | ||
35518 | if (dec_BER_PDU('3106800100810105'O) == myValue) | |
35519 | ||
35520 | ||
35521 | ||
35522 | {setverdict(pass);} else {setverdict(fail);} | |
35523 | ||
35524 | ||
35525 | <RESULT> | |
35526 | ||
35527 | Overall verdict: pass | |
35528 | ||
35529 | <END_TC> | |
35530 | ||
35531 | :exmp. | |
35532 | ||
35533 | .*---------------------------------------------------------------------* | |
35534 | :h3. DECODING CER ,SET (one element is not equal to Default) AUTOMATIC TAGGING | |
35535 | .*---------------------------------------------------------------------* | |
35536 | :xmp tab=0. | |
35537 | ||
35538 | <TC - DECODING CER ,SET (one element is not equal to Default) AUTOMATIC TAGGING> | |
35539 | ||
35540 | <STATIC:ASN> | |
35541 | ||
35542 | TempA | |
35543 | ||
35544 | DEFINITIONS | |
35545 | ||
35546 | AUTOMATIC TAGS | |
35547 | ||
35548 | ||
35549 | ::= | |
35550 | ||
35551 | BEGIN | |
35552 | ||
35553 | ||
35554 | BERPDU ::= SET | |
35555 | { | |
35556 | b BOOLEAN DEFAULT TRUE, | |
35557 | c INTEGER OPTIONAL | |
35558 | } | |
35559 | ||
35560 | ||
35561 | ||
35562 | END | |
35563 | ||
35564 | <STATIC> | |
35565 | ||
35566 | import from TempA all; | |
35567 | ||
35568 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35569 | ||
35570 | ||
35571 | const BERPDU myValue := {b := false, | |
35572 | c := 5 } | |
35573 | ||
35574 | <TTCN_TC:EXEC> | |
35575 | ||
35576 | if (dec_BER_PDU('31808001008101050000'O) == myValue) | |
35577 | ||
35578 | ||
35579 | ||
35580 | {setverdict(pass);} else {setverdict(fail);} | |
35581 | ||
35582 | ||
35583 | <RESULT> | |
35584 | ||
35585 | Overall verdict: pass | |
35586 | ||
35587 | <END_TC> | |
35588 | ||
35589 | :exmp. | |
35590 | ||
35591 | .*---------------------------------------------------------------------* | |
35592 | :h3. DECODING,reverse order,SET (one element is not equal to Default) AUTOMATIC TAGGING | |
35593 | .*---------------------------------------------------------------------* | |
35594 | :xmp tab=0. | |
35595 | ||
35596 | <TC - DECODING,reverse order,SET (one element is not equal to Default) AUTOMATIC TAGGING> | |
35597 | ||
35598 | <STATIC:ASN> | |
35599 | ||
35600 | TempA | |
35601 | ||
35602 | DEFINITIONS | |
35603 | ||
35604 | AUTOMATIC TAGS | |
35605 | ||
35606 | ||
35607 | ::= | |
35608 | ||
35609 | BEGIN | |
35610 | ||
35611 | ||
35612 | BERPDU ::= SET | |
35613 | { | |
35614 | b BOOLEAN DEFAULT TRUE, | |
35615 | c INTEGER OPTIONAL | |
35616 | } | |
35617 | ||
35618 | ||
35619 | ||
35620 | END | |
35621 | ||
35622 | <STATIC> | |
35623 | ||
35624 | import from TempA all; | |
35625 | ||
35626 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35627 | ||
35628 | ||
35629 | const BERPDU myValue := {b := false, | |
35630 | c := 5 } | |
35631 | ||
35632 | <TTCN_TC:EXEC> | |
35633 | ||
35634 | if (dec_BER_PDU('3106810105800100'O) == myValue) | |
35635 | ||
35636 | ||
35637 | ||
35638 | {setverdict(pass);} else {setverdict(fail);} | |
35639 | ||
35640 | ||
35641 | <RESULT> | |
35642 | ||
35643 | Overall verdict: pass | |
35644 | ||
35645 | <END_TC> | |
35646 | ||
35647 | :exmp. | |
35648 | ||
35649 | .*---------------------------------------------------------------------* | |
35650 | :h3. DECODING CER ,SET (one element is not equal to Default) AUTOMATIC TAGGING | |
35651 | .*---------------------------------------------------------------------* | |
35652 | :xmp tab=0. | |
35653 | ||
35654 | <TC - DECODING CER ,SET (one element is not equal to Default) AUTOMATIC TAGGING> | |
35655 | ||
35656 | <STATIC:ASN> | |
35657 | ||
35658 | TempA | |
35659 | ||
35660 | DEFINITIONS | |
35661 | ||
35662 | AUTOMATIC TAGS | |
35663 | ||
35664 | ||
35665 | ::= | |
35666 | ||
35667 | BEGIN | |
35668 | ||
35669 | ||
35670 | BERPDU ::= SET | |
35671 | { | |
35672 | b BOOLEAN DEFAULT TRUE, | |
35673 | c INTEGER OPTIONAL | |
35674 | } | |
35675 | ||
35676 | ||
35677 | ||
35678 | END | |
35679 | ||
35680 | <STATIC> | |
35681 | ||
35682 | import from TempA all; | |
35683 | ||
35684 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35685 | ||
35686 | ||
35687 | const BERPDU myValue := {b := false, | |
35688 | c := 5 } | |
35689 | ||
35690 | <TTCN_TC:EXEC> | |
35691 | ||
35692 | if (dec_BER_PDU('31808101058001000000'O) == myValue) | |
35693 | ||
35694 | ||
35695 | ||
35696 | {setverdict(pass);} else {setverdict(fail);} | |
35697 | ||
35698 | ||
35699 | <RESULT> | |
35700 | ||
35701 | Overall verdict: pass | |
35702 | ||
35703 | <END_TC> | |
35704 | ||
35705 | :exmp. | |
35706 | ||
35707 | .*---------------------------------------------------------------------* | |
35708 | :h3. DECODING DER , SET (both elements are used) IMPLICIT TAGS for elements | |
35709 | .*---------------------------------------------------------------------* | |
35710 | :xmp tab=0. | |
35711 | ||
35712 | <TC - DECODING DER , SET (both elements are used) IMPLICIT TAGS for elements> | |
35713 | ||
35714 | <STATIC:ASN> | |
35715 | ||
35716 | TempA | |
35717 | ||
35718 | DEFINITIONS | |
35719 | ||
35720 | ||
35721 | ||
35722 | ||
35723 | ::= | |
35724 | ||
35725 | BEGIN | |
35726 | ||
35727 | ||
35728 | BERPDU ::= SET | |
35729 | { | |
35730 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
35731 | c [31] IMPLICIT INTEGER OPTIONAL | |
35732 | } | |
35733 | ||
35734 | ||
35735 | END | |
35736 | ||
35737 | <STATIC> | |
35738 | ||
35739 | import from TempA all; | |
35740 | ||
35741 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35742 | ||
35743 | ||
35744 | const BERPDU myValue := {b := true, | |
35745 | c := 5 } | |
35746 | ||
35747 | <TTCN_TC:EXEC> | |
35748 | ||
35749 | if (dec_BER_PDU('31079E01FF9F1F0105'O) == myValue) | |
35750 | ||
35751 | ||
35752 | ||
35753 | {setverdict(pass);} else {setverdict(fail);} | |
35754 | ||
35755 | ||
35756 | <RESULT> | |
35757 | ||
35758 | Overall verdict: pass | |
35759 | ||
35760 | <END_TC> | |
35761 | ||
35762 | :exmp. | |
35763 | ||
35764 | .*---------------------------------------------------------------------* | |
35765 | :h3. DECODING CER , SET (both elements are used) IMPLICIT TAGS for elements | |
35766 | .*---------------------------------------------------------------------* | |
35767 | :xmp tab=0. | |
35768 | ||
35769 | <TC - DECODING CER , SET (both elements are used) IMPLICIT TAGS for elements> | |
35770 | ||
35771 | <STATIC:ASN> | |
35772 | ||
35773 | TempA | |
35774 | ||
35775 | DEFINITIONS | |
35776 | ||
35777 | ||
35778 | ||
35779 | ||
35780 | ::= | |
35781 | ||
35782 | BEGIN | |
35783 | ||
35784 | ||
35785 | BERPDU ::= SET | |
35786 | { | |
35787 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
35788 | c [31] IMPLICIT INTEGER OPTIONAL | |
35789 | } | |
35790 | ||
35791 | ||
35792 | END | |
35793 | ||
35794 | <STATIC> | |
35795 | ||
35796 | import from TempA all; | |
35797 | ||
35798 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35799 | ||
35800 | ||
35801 | const BERPDU myValue := {b := true, | |
35802 | c := 5 } | |
35803 | ||
35804 | <TTCN_TC:EXEC> | |
35805 | ||
35806 | if (dec_BER_PDU('31809E01FF9F1F01050000'O) == myValue) | |
35807 | ||
35808 | ||
35809 | ||
35810 | {setverdict(pass);} else {setverdict(fail);} | |
35811 | ||
35812 | ||
35813 | <RESULT> | |
35814 | ||
35815 | Overall verdict: pass | |
35816 | ||
35817 | <END_TC> | |
35818 | ||
35819 | :exmp. | |
35820 | ||
35821 | .*---------------------------------------------------------------------* | |
35822 | :h3. DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements | |
35823 | .*---------------------------------------------------------------------* | |
35824 | :xmp tab=0. | |
35825 | ||
35826 | <TC - DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements> | |
35827 | ||
35828 | <STATIC:ASN> | |
35829 | ||
35830 | TempA | |
35831 | ||
35832 | DEFINITIONS | |
35833 | ||
35834 | ||
35835 | ||
35836 | ||
35837 | ::= | |
35838 | ||
35839 | BEGIN | |
35840 | ||
35841 | ||
35842 | BERPDU ::= SET | |
35843 | { | |
35844 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
35845 | c [31] IMPLICIT INTEGER OPTIONAL | |
35846 | } | |
35847 | ||
35848 | ||
35849 | END | |
35850 | ||
35851 | <STATIC> | |
35852 | ||
35853 | import from TempA all; | |
35854 | ||
35855 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35856 | ||
35857 | ||
35858 | const BERPDU myValue := {b := true, | |
35859 | c := 5 } | |
35860 | ||
35861 | <TTCN_TC:EXEC> | |
35862 | ||
35863 | if (dec_BER_PDU('31079F1F01059E01FF'O) == myValue) | |
35864 | ||
35865 | ||
35866 | ||
35867 | {setverdict(pass);} else {setverdict(fail);} | |
35868 | ||
35869 | ||
35870 | <RESULT> | |
35871 | ||
35872 | Overall verdict: pass | |
35873 | ||
35874 | <END_TC> | |
35875 | ||
35876 | :exmp. | |
35877 | ||
35878 | .*---------------------------------------------------------------------* | |
35879 | :h3. DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements | |
35880 | .*---------------------------------------------------------------------* | |
35881 | :xmp tab=0. | |
35882 | ||
35883 | <TC - DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements> | |
35884 | ||
35885 | <STATIC:ASN> | |
35886 | ||
35887 | TempA | |
35888 | ||
35889 | DEFINITIONS | |
35890 | ||
35891 | ||
35892 | ||
35893 | ||
35894 | ::= | |
35895 | ||
35896 | BEGIN | |
35897 | ||
35898 | ||
35899 | BERPDU ::= SET | |
35900 | { | |
35901 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
35902 | c [31] IMPLICIT INTEGER OPTIONAL | |
35903 | } | |
35904 | ||
35905 | ||
35906 | END | |
35907 | ||
35908 | <STATIC> | |
35909 | ||
35910 | import from TempA all; | |
35911 | ||
35912 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35913 | ||
35914 | ||
35915 | const BERPDU myValue := {b := true, | |
35916 | c := 5 } | |
35917 | ||
35918 | <TTCN_TC:EXEC> | |
35919 | ||
35920 | if (dec_BER_PDU('31809F1F01059E01FF0000'O) == myValue) | |
35921 | ||
35922 | ||
35923 | ||
35924 | {setverdict(pass);} else {setverdict(fail);} | |
35925 | ||
35926 | ||
35927 | <RESULT> | |
35928 | ||
35929 | Overall verdict: pass | |
35930 | ||
35931 | <END_TC> | |
35932 | ||
35933 | :exmp. | |
35934 | ||
35935 | .*---------------------------------------------------------------------* | |
35936 | :h3. DECODING DER , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT | |
35937 | .*---------------------------------------------------------------------* | |
35938 | :xmp tab=0. | |
35939 | ||
35940 | <TC - DECODING DER , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT> | |
35941 | ||
35942 | <STATIC:ASN> | |
35943 | ||
35944 | TempA | |
35945 | ||
35946 | DEFINITIONS | |
35947 | ||
35948 | EXPLICIT TAGS | |
35949 | ||
35950 | ||
35951 | ::= | |
35952 | ||
35953 | BEGIN | |
35954 | ||
35955 | ||
35956 | BERPDU ::= SET | |
35957 | { | |
35958 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
35959 | c [31] IMPLICIT INTEGER OPTIONAL | |
35960 | } | |
35961 | ||
35962 | ||
35963 | ||
35964 | END | |
35965 | ||
35966 | <STATIC> | |
35967 | ||
35968 | import from TempA all; | |
35969 | ||
35970 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
35971 | ||
35972 | ||
35973 | const BERPDU myValue := {b := true, | |
35974 | c := 5 } | |
35975 | ||
35976 | ||
35977 | <TTCN_TC:EXEC> | |
35978 | ||
35979 | if (dec_BER_PDU('31079E01FF9F1F0105'O) == myValue) | |
35980 | ||
35981 | ||
35982 | ||
35983 | {setverdict(pass);} else {setverdict(fail);} | |
35984 | ||
35985 | ||
35986 | <RESULT> | |
35987 | ||
35988 | Overall verdict: pass | |
35989 | ||
35990 | <END_TC> | |
35991 | ||
35992 | :exmp. | |
35993 | ||
35994 | .*---------------------------------------------------------------------* | |
35995 | :h3. DECODING CER , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT | |
35996 | .*---------------------------------------------------------------------* | |
35997 | :xmp tab=0. | |
35998 | ||
35999 | <TC - DECODING CER , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT> | |
36000 | ||
36001 | <STATIC:ASN> | |
36002 | ||
36003 | TempA | |
36004 | ||
36005 | DEFINITIONS | |
36006 | ||
36007 | EXPLICIT TAGS | |
36008 | ||
36009 | ||
36010 | ::= | |
36011 | ||
36012 | BEGIN | |
36013 | ||
36014 | ||
36015 | BERPDU ::= SET | |
36016 | { | |
36017 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
36018 | c [31] IMPLICIT INTEGER OPTIONAL | |
36019 | } | |
36020 | ||
36021 | ||
36022 | ||
36023 | END | |
36024 | ||
36025 | <STATIC> | |
36026 | ||
36027 | import from TempA all; | |
36028 | ||
36029 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36030 | ||
36031 | ||
36032 | const BERPDU myValue := {b := true, | |
36033 | c := 5 } | |
36034 | ||
36035 | ||
36036 | <TTCN_TC:EXEC> | |
36037 | ||
36038 | if (dec_BER_PDU('31809E01FF9F1F01050000'O) == myValue) | |
36039 | ||
36040 | ||
36041 | ||
36042 | {setverdict(pass);} else {setverdict(fail);} | |
36043 | ||
36044 | ||
36045 | <RESULT> | |
36046 | ||
36047 | Overall verdict: pass | |
36048 | ||
36049 | <END_TC> | |
36050 | ||
36051 | :exmp. | |
36052 | ||
36053 | .*---------------------------------------------------------------------* | |
36054 | :h3. DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT | |
36055 | .*---------------------------------------------------------------------* | |
36056 | :xmp tab=0. | |
36057 | ||
36058 | <TC - DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT> | |
36059 | ||
36060 | <STATIC:ASN> | |
36061 | ||
36062 | TempA | |
36063 | ||
36064 | DEFINITIONS | |
36065 | ||
36066 | EXPLICIT TAGS | |
36067 | ||
36068 | ||
36069 | ::= | |
36070 | ||
36071 | BEGIN | |
36072 | ||
36073 | ||
36074 | BERPDU ::= SET | |
36075 | { | |
36076 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
36077 | c [31] IMPLICIT INTEGER OPTIONAL | |
36078 | } | |
36079 | ||
36080 | ||
36081 | ||
36082 | END | |
36083 | ||
36084 | <STATIC> | |
36085 | ||
36086 | import from TempA all; | |
36087 | ||
36088 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36089 | ||
36090 | ||
36091 | const BERPDU myValue := {b := true, | |
36092 | c := 5 } | |
36093 | ||
36094 | ||
36095 | <TTCN_TC:EXEC> | |
36096 | ||
36097 | if (dec_BER_PDU('31079F1F01059E01FF'O) == myValue) | |
36098 | ||
36099 | ||
36100 | ||
36101 | {setverdict(pass);} else {setverdict(fail);} | |
36102 | ||
36103 | ||
36104 | <RESULT> | |
36105 | ||
36106 | Overall verdict: pass | |
36107 | ||
36108 | <END_TC> | |
36109 | ||
36110 | :exmp. | |
36111 | ||
36112 | .*---------------------------------------------------------------------* | |
36113 | :h3. DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT | |
36114 | .*---------------------------------------------------------------------* | |
36115 | :xmp tab=0. | |
36116 | ||
36117 | <TC - DECODING , reverse order , SET (both elements are used) IMPLICIT TAGS for elements, EXPLICIT TAGGING ENVIRONMENT> | |
36118 | ||
36119 | <STATIC:ASN> | |
36120 | ||
36121 | TempA | |
36122 | ||
36123 | DEFINITIONS | |
36124 | ||
36125 | EXPLICIT TAGS | |
36126 | ||
36127 | ||
36128 | ::= | |
36129 | ||
36130 | BEGIN | |
36131 | ||
36132 | ||
36133 | BERPDU ::= SET | |
36134 | { | |
36135 | b [30] IMPLICIT BOOLEAN OPTIONAL, | |
36136 | c [31] IMPLICIT INTEGER OPTIONAL | |
36137 | } | |
36138 | ||
36139 | ||
36140 | ||
36141 | END | |
36142 | ||
36143 | <STATIC> | |
36144 | ||
36145 | import from TempA all; | |
36146 | ||
36147 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36148 | ||
36149 | ||
36150 | const BERPDU myValue := {b := true, | |
36151 | c := 5 } | |
36152 | ||
36153 | ||
36154 | <TTCN_TC:EXEC> | |
36155 | ||
36156 | if (dec_BER_PDU('31809F1F01059E01FF0000'O) == myValue) | |
36157 | ||
36158 | ||
36159 | ||
36160 | {setverdict(pass);} else {setverdict(fail);} | |
36161 | ||
36162 | ||
36163 | <RESULT> | |
36164 | ||
36165 | Overall verdict: pass | |
36166 | ||
36167 | <END_TC> | |
36168 | ||
36169 | :exmp. | |
36170 | ||
36171 | .*---------------------------------------------------------------------* | |
36172 | :h3. DECODING DER, SET (both elements are used) EXPLICIT TAGS for elements | |
36173 | .*---------------------------------------------------------------------* | |
36174 | :xmp tab=0. | |
36175 | ||
36176 | <TC - DECODING DER, SET (both elements are used) EXPLICIT TAGS for elements> | |
36177 | ||
36178 | <STATIC:ASN> | |
36179 | ||
36180 | TempA | |
36181 | ||
36182 | DEFINITIONS | |
36183 | ||
36184 | ||
36185 | ||
36186 | ::= | |
36187 | ||
36188 | BEGIN | |
36189 | ||
36190 | ||
36191 | BERPDU ::= SET | |
36192 | { | |
36193 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
36194 | c [31] EXPLICIT INTEGER OPTIONAL | |
36195 | } | |
36196 | ||
36197 | ||
36198 | ||
36199 | END | |
36200 | ||
36201 | <STATIC> | |
36202 | ||
36203 | import from TempA all; | |
36204 | ||
36205 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36206 | ||
36207 | ||
36208 | const BERPDU myValue := {b := true, | |
36209 | c := 5 } | |
36210 | ||
36211 | ||
36212 | <TTCN_TC:EXEC> | |
36213 | ||
36214 | if (dec_BER_PDU('310BBE030101FFBF1F03020105'O) == myValue) | |
36215 | ||
36216 | ||
36217 | ||
36218 | {setverdict(pass);} else {setverdict(fail);} | |
36219 | ||
36220 | ||
36221 | <RESULT> | |
36222 | ||
36223 | Overall verdict: pass | |
36224 | ||
36225 | <END_TC> | |
36226 | ||
36227 | :exmp. | |
36228 | ||
36229 | .*---------------------------------------------------------------------* | |
36230 | :h3. DECODING CER, SET (both elements are used) EXPLICIT TAGS for elements | |
36231 | .*---------------------------------------------------------------------* | |
36232 | :xmp tab=0. | |
36233 | ||
36234 | <TC - DECODING CER, SET (both elements are used) EXPLICIT TAGS for elements> | |
36235 | ||
36236 | <STATIC:ASN> | |
36237 | ||
36238 | TempA | |
36239 | ||
36240 | DEFINITIONS | |
36241 | ||
36242 | ||
36243 | ||
36244 | ::= | |
36245 | ||
36246 | BEGIN | |
36247 | ||
36248 | ||
36249 | BERPDU ::= SET | |
36250 | { | |
36251 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
36252 | c [31] EXPLICIT INTEGER OPTIONAL | |
36253 | } | |
36254 | ||
36255 | ||
36256 | ||
36257 | END | |
36258 | ||
36259 | <STATIC> | |
36260 | ||
36261 | import from TempA all; | |
36262 | ||
36263 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36264 | ||
36265 | ||
36266 | const BERPDU myValue := {b := true, | |
36267 | c := 5 } | |
36268 | ||
36269 | ||
36270 | <TTCN_TC:EXEC> | |
36271 | ||
36272 | if (dec_BER_PDU('3180BE800101FF0000BF1F8002010500000000'O) == myValue) | |
36273 | ||
36274 | ||
36275 | ||
36276 | {setverdict(pass);} else {setverdict(fail);} | |
36277 | ||
36278 | ||
36279 | <RESULT> | |
36280 | ||
36281 | Overall verdict: pass | |
36282 | ||
36283 | <END_TC> | |
36284 | ||
36285 | :exmp. | |
36286 | ||
36287 | .*---------------------------------------------------------------------* | |
36288 | :h3. DECODING , reverse order, SET (both elements are used) EXPLICIT TAGS for elements | |
36289 | .*---------------------------------------------------------------------* | |
36290 | :xmp tab=0. | |
36291 | ||
36292 | <TC - DECODING , reverse order, SET (both elements are used) EXPLICIT TAGS for elements> | |
36293 | ||
36294 | <STATIC:ASN> | |
36295 | ||
36296 | TempA | |
36297 | ||
36298 | DEFINITIONS | |
36299 | ||
36300 | ||
36301 | ||
36302 | ::= | |
36303 | ||
36304 | BEGIN | |
36305 | ||
36306 | ||
36307 | BERPDU ::= SET | |
36308 | { | |
36309 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
36310 | c [31] EXPLICIT INTEGER OPTIONAL | |
36311 | } | |
36312 | ||
36313 | ||
36314 | ||
36315 | END | |
36316 | ||
36317 | <STATIC> | |
36318 | ||
36319 | import from TempA all; | |
36320 | ||
36321 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36322 | ||
36323 | ||
36324 | const BERPDU myValue := {b := true, | |
36325 | c := 5 } | |
36326 | ||
36327 | ||
36328 | <TTCN_TC:EXEC> | |
36329 | ||
36330 | if (dec_BER_PDU('310BBF1F03020105BE030101FF'O) == myValue) | |
36331 | ||
36332 | ||
36333 | ||
36334 | {setverdict(pass);} else {setverdict(fail);} | |
36335 | ||
36336 | ||
36337 | <RESULT> | |
36338 | ||
36339 | Overall verdict: pass | |
36340 | ||
36341 | <END_TC> | |
36342 | ||
36343 | :exmp. | |
36344 | ||
36345 | .*---------------------------------------------------------------------* | |
36346 | :h3. DECODING , reverse order, SET (both elements are used) EXPLICIT TAGS for elements | |
36347 | .*---------------------------------------------------------------------* | |
36348 | :xmp tab=0. | |
36349 | ||
36350 | <TC - DECODING , reverse order, SET (both elements are used) EXPLICIT TAGS for elements> | |
36351 | ||
36352 | <STATIC:ASN> | |
36353 | ||
36354 | TempA | |
36355 | ||
36356 | DEFINITIONS | |
36357 | ||
36358 | ||
36359 | ||
36360 | ::= | |
36361 | ||
36362 | BEGIN | |
36363 | ||
36364 | ||
36365 | BERPDU ::= SET | |
36366 | { | |
36367 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
36368 | c [31] EXPLICIT INTEGER OPTIONAL | |
36369 | } | |
36370 | ||
36371 | ||
36372 | ||
36373 | END | |
36374 | ||
36375 | <STATIC> | |
36376 | ||
36377 | import from TempA all; | |
36378 | ||
36379 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36380 | ||
36381 | ||
36382 | const BERPDU myValue := {b := true, | |
36383 | c := 5 } | |
36384 | ||
36385 | ||
36386 | <TTCN_TC:EXEC> | |
36387 | ||
36388 | if (dec_BER_PDU('3180BF1F800201050000BE800101FF00000000'O) == myValue) | |
36389 | ||
36390 | ||
36391 | ||
36392 | {setverdict(pass);} else {setverdict(fail);} | |
36393 | ||
36394 | ||
36395 | <RESULT> | |
36396 | ||
36397 | Overall verdict: pass | |
36398 | ||
36399 | <END_TC> | |
36400 | ||
36401 | :exmp. | |
36402 | ||
36403 | .*---------------------------------------------------------------------* | |
36404 | :h3. DECODING DER , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT | |
36405 | .*---------------------------------------------------------------------* | |
36406 | :xmp tab=0. | |
36407 | ||
36408 | <TC - DECODING DER , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT> | |
36409 | ||
36410 | <STATIC:ASN> | |
36411 | ||
36412 | TempA | |
36413 | ||
36414 | DEFINITIONS | |
36415 | ||
36416 | IMPLICIT TAGS | |
36417 | ||
36418 | ||
36419 | ::= | |
36420 | ||
36421 | BEGIN | |
36422 | ||
36423 | ||
36424 | BERPDU ::= SET | |
36425 | { | |
36426 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
36427 | c [31] EXPLICIT INTEGER OPTIONAL | |
36428 | } | |
36429 | ||
36430 | ||
36431 | END | |
36432 | ||
36433 | <STATIC> | |
36434 | ||
36435 | import from TempA all; | |
36436 | ||
36437 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36438 | ||
36439 | ||
36440 | const BERPDU myValue := {b := true, | |
36441 | c := 5 } | |
36442 | ||
36443 | ||
36444 | ||
36445 | <TTCN_TC:EXEC> | |
36446 | ||
36447 | if (dec_BER_PDU('310BBE030101FFBF1F03020105'O) == myValue) | |
36448 | ||
36449 | ||
36450 | ||
36451 | {setverdict(pass);} else {setverdict(fail);} | |
36452 | ||
36453 | ||
36454 | <RESULT> | |
36455 | ||
36456 | Overall verdict: pass | |
36457 | ||
36458 | <END_TC> | |
36459 | ||
36460 | :exmp. | |
36461 | ||
36462 | .*---------------------------------------------------------------------* | |
36463 | :h3. DECODING CER , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT | |
36464 | .*---------------------------------------------------------------------* | |
36465 | :xmp tab=0. | |
36466 | ||
36467 | <TC - DECODING CER , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT> | |
36468 | ||
36469 | <STATIC:ASN> | |
36470 | ||
36471 | TempA | |
36472 | ||
36473 | DEFINITIONS | |
36474 | ||
36475 | IMPLICIT TAGS | |
36476 | ||
36477 | ||
36478 | ::= | |
36479 | ||
36480 | BEGIN | |
36481 | ||
36482 | ||
36483 | BERPDU ::= SET | |
36484 | { | |
36485 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
36486 | c [31] EXPLICIT INTEGER OPTIONAL | |
36487 | } | |
36488 | ||
36489 | ||
36490 | END | |
36491 | ||
36492 | <STATIC> | |
36493 | ||
36494 | import from TempA all; | |
36495 | ||
36496 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36497 | ||
36498 | ||
36499 | const BERPDU myValue := {b := true, | |
36500 | c := 5 } | |
36501 | ||
36502 | ||
36503 | ||
36504 | <TTCN_TC:EXEC> | |
36505 | ||
36506 | if (dec_BER_PDU('3180BE800101FF0000BF1F8002010500000000'O) == myValue) | |
36507 | ||
36508 | ||
36509 | ||
36510 | {setverdict(pass);} else {setverdict(fail);} | |
36511 | ||
36512 | ||
36513 | <RESULT> | |
36514 | ||
36515 | Overall verdict: pass | |
36516 | ||
36517 | <END_TC> | |
36518 | ||
36519 | :exmp. | |
36520 | ||
36521 | .*---------------------------------------------------------------------* | |
36522 | :h3. DECODING , reverse order , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT | |
36523 | .*---------------------------------------------------------------------* | |
36524 | :xmp tab=0. | |
36525 | ||
36526 | <TC - DECODING , reverse order , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT> | |
36527 | ||
36528 | <STATIC:ASN> | |
36529 | ||
36530 | TempA | |
36531 | ||
36532 | DEFINITIONS | |
36533 | ||
36534 | IMPLICIT TAGS | |
36535 | ||
36536 | ||
36537 | ::= | |
36538 | ||
36539 | BEGIN | |
36540 | ||
36541 | ||
36542 | BERPDU ::= SET | |
36543 | { | |
36544 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
36545 | c [31] EXPLICIT INTEGER OPTIONAL | |
36546 | } | |
36547 | ||
36548 | ||
36549 | END | |
36550 | ||
36551 | <STATIC> | |
36552 | ||
36553 | import from TempA all; | |
36554 | ||
36555 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36556 | ||
36557 | ||
36558 | const BERPDU myValue := {b := true, | |
36559 | c := 5 } | |
36560 | ||
36561 | ||
36562 | ||
36563 | <TTCN_TC:EXEC> | |
36564 | ||
36565 | if (dec_BER_PDU('310BBF1F03020105BE030101FF'O) == myValue) | |
36566 | ||
36567 | ||
36568 | ||
36569 | {setverdict(pass);} else {setverdict(fail);} | |
36570 | ||
36571 | ||
36572 | <RESULT> | |
36573 | ||
36574 | Overall verdict: pass | |
36575 | ||
36576 | <END_TC> | |
36577 | ||
36578 | :exmp. | |
36579 | ||
36580 | .*---------------------------------------------------------------------* | |
36581 | :h3. DECODING , reverse order , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT | |
36582 | .*---------------------------------------------------------------------* | |
36583 | :xmp tab=0. | |
36584 | ||
36585 | <TC - DECODING , reverse order , SET (both elements are used) EXPLICIT TAGS for elements, IMPLICIT TAGGING ENVIRONMENT> | |
36586 | ||
36587 | <STATIC:ASN> | |
36588 | ||
36589 | TempA | |
36590 | ||
36591 | DEFINITIONS | |
36592 | ||
36593 | IMPLICIT TAGS | |
36594 | ||
36595 | ||
36596 | ::= | |
36597 | ||
36598 | BEGIN | |
36599 | ||
36600 | ||
36601 | BERPDU ::= SET | |
36602 | { | |
36603 | b [30] EXPLICIT BOOLEAN OPTIONAL, | |
36604 | c [31] EXPLICIT INTEGER OPTIONAL | |
36605 | } | |
36606 | ||
36607 | ||
36608 | END | |
36609 | ||
36610 | <STATIC> | |
36611 | ||
36612 | import from TempA all; | |
36613 | ||
36614 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36615 | ||
36616 | ||
36617 | const BERPDU myValue := {b := true, | |
36618 | c := 5 } | |
36619 | ||
36620 | ||
36621 | ||
36622 | <TTCN_TC:EXEC> | |
36623 | ||
36624 | if (dec_BER_PDU('3180BF1F800201050000BE800101FF00000000'O) == myValue) | |
36625 | ||
36626 | ||
36627 | ||
36628 | {setverdict(pass);} else {setverdict(fail);} | |
36629 | ||
36630 | ||
36631 | <RESULT> | |
36632 | ||
36633 | Overall verdict: pass | |
36634 | ||
36635 | <END_TC> | |
36636 | ||
36637 | :exmp. | |
36638 | ||
36639 | .*---------------------------------------------------------------------* | |
36640 | :h3. DECODING , DER , TAGGED SET (both elements are used) | |
36641 | .*---------------------------------------------------------------------* | |
36642 | :xmp tab=0. | |
36643 | ||
36644 | <TC - DECODING , DER , TAGGED SET (both elements are used)> | |
36645 | ||
36646 | <STATIC:ASN> | |
36647 | ||
36648 | TempA | |
36649 | ||
36650 | DEFINITIONS | |
36651 | ||
36652 | ||
36653 | ||
36654 | ::= | |
36655 | ||
36656 | BEGIN | |
36657 | ||
36658 | ||
36659 | BERPDU ::= [0] SET | |
36660 | { | |
36661 | b BOOLEAN OPTIONAL, | |
36662 | c INTEGER OPTIONAL | |
36663 | } | |
36664 | ||
36665 | ||
36666 | END | |
36667 | ||
36668 | <STATIC> | |
36669 | ||
36670 | import from TempA all; | |
36671 | ||
36672 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36673 | ||
36674 | ||
36675 | const BERPDU myValue := {b := true, | |
36676 | c := 5 } | |
36677 | ||
36678 | ||
36679 | ||
36680 | <TTCN_TC:EXEC> | |
36681 | ||
36682 | if (dec_BER_PDU('A00831060101FF020105'O) == myValue) | |
36683 | ||
36684 | ||
36685 | ||
36686 | {setverdict(pass);} else {setverdict(fail);} | |
36687 | ||
36688 | ||
36689 | <RESULT> | |
36690 | ||
36691 | Overall verdict: pass | |
36692 | ||
36693 | <END_TC> | |
36694 | ||
36695 | :exmp. | |
36696 | ||
36697 | .*---------------------------------------------------------------------* | |
36698 | :h3. DECODING , CER , TAGGED SET (both elements are used) | |
36699 | .*---------------------------------------------------------------------* | |
36700 | :xmp tab=0. | |
36701 | ||
36702 | <TC - DECODING , CER , TAGGED SET (both elements are used)> | |
36703 | ||
36704 | <STATIC:ASN> | |
36705 | ||
36706 | TempA | |
36707 | ||
36708 | DEFINITIONS | |
36709 | ||
36710 | ||
36711 | ||
36712 | ::= | |
36713 | ||
36714 | BEGIN | |
36715 | ||
36716 | ||
36717 | BERPDU ::= [0] SET | |
36718 | { | |
36719 | b BOOLEAN OPTIONAL, | |
36720 | c INTEGER OPTIONAL | |
36721 | } | |
36722 | ||
36723 | ||
36724 | END | |
36725 | ||
36726 | <STATIC> | |
36727 | ||
36728 | import from TempA all; | |
36729 | ||
36730 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36731 | ||
36732 | ||
36733 | const BERPDU myValue := {b := true, | |
36734 | c := 5 } | |
36735 | ||
36736 | ||
36737 | ||
36738 | <TTCN_TC:EXEC> | |
36739 | ||
36740 | if (dec_BER_PDU('A08031800101FF02010500000000'O) == myValue) | |
36741 | ||
36742 | ||
36743 | ||
36744 | {setverdict(pass);} else {setverdict(fail);} | |
36745 | ||
36746 | ||
36747 | <RESULT> | |
36748 | ||
36749 | Overall verdict: pass | |
36750 | ||
36751 | <END_TC> | |
36752 | ||
36753 | :exmp. | |
36754 | ||
36755 | .*---------------------------------------------------------------------* | |
36756 | :h3. DECODING , reverse order , TAGGED SET (both elements are used) | |
36757 | .*---------------------------------------------------------------------* | |
36758 | :xmp tab=0. | |
36759 | ||
36760 | <TC - DECODING , reverse order , TAGGED SET (both elements are used)> | |
36761 | ||
36762 | <STATIC:ASN> | |
36763 | ||
36764 | TempA | |
36765 | ||
36766 | DEFINITIONS | |
36767 | ||
36768 | ||
36769 | ||
36770 | ::= | |
36771 | ||
36772 | BEGIN | |
36773 | ||
36774 | ||
36775 | BERPDU ::= [0] SET | |
36776 | { | |
36777 | b BOOLEAN OPTIONAL, | |
36778 | c INTEGER OPTIONAL | |
36779 | } | |
36780 | ||
36781 | ||
36782 | END | |
36783 | ||
36784 | <STATIC> | |
36785 | ||
36786 | import from TempA all; | |
36787 | ||
36788 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36789 | ||
36790 | ||
36791 | const BERPDU myValue := {b := true, | |
36792 | c := 5 } | |
36793 | ||
36794 | ||
36795 | ||
36796 | <TTCN_TC:EXEC> | |
36797 | ||
36798 | if (dec_BER_PDU('A00831060201050101FF'O) == myValue) | |
36799 | ||
36800 | ||
36801 | ||
36802 | {setverdict(pass);} else {setverdict(fail);} | |
36803 | ||
36804 | ||
36805 | <RESULT> | |
36806 | ||
36807 | Overall verdict: pass | |
36808 | ||
36809 | <END_TC> | |
36810 | ||
36811 | :exmp. | |
36812 | ||
36813 | .*---------------------------------------------------------------------* | |
36814 | :h3. DECODING ,reverse order , TAGGED SET (both elements are used) | |
36815 | .*---------------------------------------------------------------------* | |
36816 | :xmp tab=0. | |
36817 | ||
36818 | <TC - DECODING ,reverse order , TAGGED SET (both elements are used)> | |
36819 | ||
36820 | <STATIC:ASN> | |
36821 | ||
36822 | TempA | |
36823 | ||
36824 | DEFINITIONS | |
36825 | ||
36826 | ||
36827 | ||
36828 | ::= | |
36829 | ||
36830 | BEGIN | |
36831 | ||
36832 | ||
36833 | BERPDU ::= [0] SET | |
36834 | { | |
36835 | b BOOLEAN OPTIONAL, | |
36836 | c INTEGER OPTIONAL | |
36837 | } | |
36838 | ||
36839 | ||
36840 | END | |
36841 | ||
36842 | <STATIC> | |
36843 | ||
36844 | import from TempA all; | |
36845 | ||
36846 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36847 | ||
36848 | ||
36849 | const BERPDU myValue := {b := true, | |
36850 | c := 5 } | |
36851 | ||
36852 | ||
36853 | ||
36854 | <TTCN_TC:EXEC> | |
36855 | ||
36856 | if (dec_BER_PDU('A08031800201050101FF00000000'O) == myValue) | |
36857 | ||
36858 | ||
36859 | ||
36860 | {setverdict(pass);} else {setverdict(fail);} | |
36861 | ||
36862 | ||
36863 | <RESULT> | |
36864 | ||
36865 | Overall verdict: pass | |
36866 | ||
36867 | <END_TC> | |
36868 | ||
36869 | :exmp. | |
36870 | ||
36871 | .*---------------------------------------------------------------------* | |
36872 | :h3. DECODING DER , TAGGED SEQUENCE (both elements are used) | |
36873 | .*---------------------------------------------------------------------* | |
36874 | :xmp tab=0. | |
36875 | ||
36876 | <TC - DECODING DER , TAGGED SEQUENCE (both elements are used)> | |
36877 | ||
36878 | <STATIC:ASN> | |
36879 | ||
36880 | TempA | |
36881 | ||
36882 | DEFINITIONS | |
36883 | ||
36884 | ||
36885 | ||
36886 | ::= | |
36887 | ||
36888 | BEGIN | |
36889 | ||
36890 | ||
36891 | BERPDU ::= [0] SEQUENCE | |
36892 | { | |
36893 | b BOOLEAN OPTIONAL, | |
36894 | c INTEGER OPTIONAL | |
36895 | } | |
36896 | ||
36897 | END | |
36898 | ||
36899 | <STATIC> | |
36900 | ||
36901 | import from TempA all; | |
36902 | ||
36903 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36904 | ||
36905 | ||
36906 | const BERPDU myValue := {b := true, | |
36907 | c := 5 } | |
36908 | ||
36909 | ||
36910 | ||
36911 | <TTCN_TC:EXEC> | |
36912 | ||
36913 | if (dec_BER_PDU('A00831060101FF020105'O) == myValue) | |
36914 | ||
36915 | ||
36916 | ||
36917 | {setverdict(pass);} else {setverdict(fail);} | |
36918 | ||
36919 | ||
36920 | <RESULT> | |
36921 | ||
36922 | Overall verdict: pass | |
36923 | ||
36924 | <END_TC> | |
36925 | ||
36926 | :exmp. | |
36927 | ||
36928 | .*---------------------------------------------------------------------* | |
36929 | :h3. DECODING CER , TAGGED SET (both elements are used) | |
36930 | .*---------------------------------------------------------------------* | |
36931 | :xmp tab=0. | |
36932 | ||
36933 | <TC - DECODING CER , TAGGED SET (both elements are used)> | |
36934 | ||
36935 | <STATIC:ASN> | |
36936 | ||
36937 | TempA | |
36938 | ||
36939 | DEFINITIONS | |
36940 | ||
36941 | ||
36942 | ||
36943 | ::= | |
36944 | ||
36945 | BEGIN | |
36946 | ||
36947 | ||
36948 | BERPDU ::= [0] SET | |
36949 | { | |
36950 | b BOOLEAN OPTIONAL, | |
36951 | c INTEGER OPTIONAL | |
36952 | } | |
36953 | ||
36954 | END | |
36955 | ||
36956 | <STATIC> | |
36957 | ||
36958 | import from TempA all; | |
36959 | ||
36960 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
36961 | ||
36962 | ||
36963 | const BERPDU myValue := {b := true, | |
36964 | c := 5 } | |
36965 | ||
36966 | ||
36967 | ||
36968 | <TTCN_TC:EXEC> | |
36969 | ||
36970 | if (dec_BER_PDU('A08031800101FF02010500000000'O) == myValue) | |
36971 | ||
36972 | ||
36973 | ||
36974 | {setverdict(pass);} else {setverdict(fail);} | |
36975 | ||
36976 | ||
36977 | <RESULT> | |
36978 | ||
36979 | Overall verdict: pass | |
36980 | ||
36981 | <END_TC> | |
36982 | ||
36983 | :exmp. | |
36984 | ||
36985 | .*---------------------------------------------------------------------* | |
36986 | :h3. DECODING , reverse order , TAGGED SEQUENCE (both elements are used) | |
36987 | .*---------------------------------------------------------------------* | |
36988 | :xmp tab=0. | |
36989 | ||
36990 | <TC - DECODING , reverse order , TAGGED SEQUENCE (both elements are used)> | |
36991 | ||
36992 | <STATIC:ASN> | |
36993 | ||
36994 | TempA | |
36995 | ||
36996 | DEFINITIONS | |
36997 | ||
36998 | ||
36999 | ||
37000 | ::= | |
37001 | ||
37002 | BEGIN | |
37003 | ||
37004 | ||
37005 | BERPDU ::= [0] SEQUENCE | |
37006 | { | |
37007 | b BOOLEAN OPTIONAL, | |
37008 | c INTEGER OPTIONAL | |
37009 | } | |
37010 | ||
37011 | END | |
37012 | ||
37013 | <STATIC> | |
37014 | ||
37015 | import from TempA all; | |
37016 | ||
37017 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37018 | ||
37019 | ||
37020 | const BERPDU myValue := {b := true, | |
37021 | c := 5 } | |
37022 | ||
37023 | ||
37024 | ||
37025 | <TTCN_TC:EXEC> | |
37026 | ||
37027 | if (dec_BER_PDU('A00831060101FF020105'O) == myValue) | |
37028 | ||
37029 | ||
37030 | ||
37031 | {setverdict(pass);} else {setverdict(fail);} | |
37032 | ||
37033 | ||
37034 | <RESULT> | |
37035 | ||
37036 | Overall verdict: pass | |
37037 | ||
37038 | <END_TC> | |
37039 | ||
37040 | :exmp. | |
37041 | ||
37042 | .*---------------------------------------------------------------------* | |
37043 | :h3. DECODING , reverse order , TAGGED SET (both elements are used) | |
37044 | .*---------------------------------------------------------------------* | |
37045 | :xmp tab=0. | |
37046 | ||
37047 | <TC - DECODING , reverse order , TAGGED SET (both elements are used)> | |
37048 | ||
37049 | <STATIC:ASN> | |
37050 | ||
37051 | TempA | |
37052 | ||
37053 | DEFINITIONS | |
37054 | ||
37055 | ||
37056 | ||
37057 | ::= | |
37058 | ||
37059 | BEGIN | |
37060 | ||
37061 | ||
37062 | BERPDU ::= [0] SET | |
37063 | { | |
37064 | b BOOLEAN OPTIONAL, | |
37065 | c INTEGER OPTIONAL | |
37066 | } | |
37067 | ||
37068 | END | |
37069 | ||
37070 | <STATIC> | |
37071 | ||
37072 | import from TempA all; | |
37073 | ||
37074 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37075 | ||
37076 | ||
37077 | const BERPDU myValue := {b := true, | |
37078 | c := 5 } | |
37079 | ||
37080 | ||
37081 | ||
37082 | <TTCN_TC:EXEC> | |
37083 | ||
37084 | if (dec_BER_PDU('A08031800201050101FF00000000'O) == myValue) | |
37085 | ||
37086 | ||
37087 | ||
37088 | {setverdict(pass);} else {setverdict(fail);} | |
37089 | ||
37090 | ||
37091 | <RESULT> | |
37092 | ||
37093 | Overall verdict: pass | |
37094 | ||
37095 | <END_TC> | |
37096 | ||
37097 | :exmp. | |
37098 | ||
37099 | .*---------------------------------------------------------------------* | |
37100 | :h3. DECODING DER , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT | |
37101 | .*---------------------------------------------------------------------* | |
37102 | :xmp tab=0. | |
37103 | ||
37104 | <TC - DECODING DER , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT> | |
37105 | ||
37106 | <STATIC:ASN> | |
37107 | ||
37108 | TempA | |
37109 | ||
37110 | DEFINITIONS | |
37111 | ||
37112 | IMPLICIT TAGS | |
37113 | ||
37114 | ||
37115 | ::= | |
37116 | ||
37117 | BEGIN | |
37118 | ||
37119 | ||
37120 | BERPDU ::= [0] SET | |
37121 | { | |
37122 | b BOOLEAN OPTIONAL, | |
37123 | c INTEGER OPTIONAL | |
37124 | } | |
37125 | ||
37126 | ||
37127 | END | |
37128 | ||
37129 | <STATIC> | |
37130 | ||
37131 | import from TempA all; | |
37132 | ||
37133 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37134 | ||
37135 | ||
37136 | const BERPDU myValue := {b := true, | |
37137 | c := 5 } | |
37138 | ||
37139 | ||
37140 | <TTCN_TC:EXEC> | |
37141 | ||
37142 | if (dec_BER_PDU('A0060101FF020105'O) == myValue) | |
37143 | ||
37144 | ||
37145 | ||
37146 | {setverdict(pass);} else {setverdict(fail);} | |
37147 | ||
37148 | ||
37149 | <RESULT> | |
37150 | ||
37151 | Overall verdict: pass | |
37152 | ||
37153 | <END_TC> | |
37154 | ||
37155 | :exmp. | |
37156 | ||
37157 | .*---------------------------------------------------------------------* | |
37158 | :h3. DECODING CER , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT | |
37159 | .*---------------------------------------------------------------------* | |
37160 | :xmp tab=0. | |
37161 | ||
37162 | <TC - DECODING CER , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT> | |
37163 | ||
37164 | <STATIC:ASN> | |
37165 | ||
37166 | TempA | |
37167 | ||
37168 | DEFINITIONS | |
37169 | ||
37170 | IMPLICIT TAGS | |
37171 | ||
37172 | ||
37173 | ::= | |
37174 | ||
37175 | BEGIN | |
37176 | ||
37177 | ||
37178 | BERPDU ::= [0] SET | |
37179 | { | |
37180 | b BOOLEAN OPTIONAL, | |
37181 | c INTEGER OPTIONAL | |
37182 | } | |
37183 | ||
37184 | ||
37185 | END | |
37186 | ||
37187 | <STATIC> | |
37188 | ||
37189 | import from TempA all; | |
37190 | ||
37191 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37192 | ||
37193 | ||
37194 | const BERPDU myValue := {b := true, | |
37195 | c := 5 } | |
37196 | ||
37197 | ||
37198 | <TTCN_TC:EXEC> | |
37199 | ||
37200 | if (dec_BER_PDU('A0800101FF0201050000'O) == myValue) | |
37201 | ||
37202 | ||
37203 | ||
37204 | {setverdict(pass);} else {setverdict(fail);} | |
37205 | ||
37206 | ||
37207 | <RESULT> | |
37208 | ||
37209 | Overall verdict: pass | |
37210 | ||
37211 | <END_TC> | |
37212 | ||
37213 | :exmp. | |
37214 | ||
37215 | .*---------------------------------------------------------------------* | |
37216 | :h3. DECODING , reverse order , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT | |
37217 | .*---------------------------------------------------------------------* | |
37218 | :xmp tab=0. | |
37219 | ||
37220 | <TC - DECODING , reverse order , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT> | |
37221 | ||
37222 | <STATIC:ASN> | |
37223 | ||
37224 | TempA | |
37225 | ||
37226 | DEFINITIONS | |
37227 | ||
37228 | IMPLICIT TAGS | |
37229 | ||
37230 | ||
37231 | ::= | |
37232 | ||
37233 | BEGIN | |
37234 | ||
37235 | ||
37236 | BERPDU ::= [0] SET | |
37237 | { | |
37238 | b BOOLEAN OPTIONAL, | |
37239 | c INTEGER OPTIONAL | |
37240 | } | |
37241 | ||
37242 | ||
37243 | END | |
37244 | ||
37245 | <STATIC> | |
37246 | ||
37247 | import from TempA all; | |
37248 | ||
37249 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37250 | ||
37251 | ||
37252 | const BERPDU myValue := {b := true, | |
37253 | c := 5 } | |
37254 | ||
37255 | ||
37256 | <TTCN_TC:EXEC> | |
37257 | ||
37258 | if (dec_BER_PDU('A0060201050101FF'O) == myValue) | |
37259 | ||
37260 | ||
37261 | ||
37262 | {setverdict(pass);} else {setverdict(fail);} | |
37263 | ||
37264 | ||
37265 | <RESULT> | |
37266 | ||
37267 | Overall verdict: pass | |
37268 | ||
37269 | <END_TC> | |
37270 | ||
37271 | :exmp. | |
37272 | ||
37273 | .*---------------------------------------------------------------------* | |
37274 | :h3. DECODING, reverse order , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT | |
37275 | .*---------------------------------------------------------------------* | |
37276 | :xmp tab=0. | |
37277 | ||
37278 | <TC - DECODING, reverse order , TAGGED SET (both elements are used), IMPLICIT TAGGING ENVIRONMENT> | |
37279 | ||
37280 | <STATIC:ASN> | |
37281 | ||
37282 | TempA | |
37283 | ||
37284 | DEFINITIONS | |
37285 | ||
37286 | IMPLICIT TAGS | |
37287 | ||
37288 | ||
37289 | ::= | |
37290 | ||
37291 | BEGIN | |
37292 | ||
37293 | ||
37294 | BERPDU ::= [0] SET | |
37295 | { | |
37296 | b BOOLEAN OPTIONAL, | |
37297 | c INTEGER OPTIONAL | |
37298 | } | |
37299 | ||
37300 | ||
37301 | END | |
37302 | ||
37303 | <STATIC> | |
37304 | ||
37305 | import from TempA all; | |
37306 | ||
37307 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37308 | ||
37309 | ||
37310 | const BERPDU myValue := {b := true, | |
37311 | c := 5 } | |
37312 | ||
37313 | ||
37314 | <TTCN_TC:EXEC> | |
37315 | ||
37316 | if (dec_BER_PDU('A0800201050101FF0000'O) == myValue) | |
37317 | ||
37318 | ||
37319 | ||
37320 | {setverdict(pass);} else {setverdict(fail);} | |
37321 | ||
37322 | ||
37323 | <RESULT> | |
37324 | ||
37325 | Overall verdict: pass | |
37326 | ||
37327 | <END_TC> | |
37328 | ||
37329 | :exmp. | |
37330 | ||
37331 | .*---------------------------------------------------------------------* | |
37332 | :h3. DECODING DER , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT | |
37333 | .*---------------------------------------------------------------------* | |
37334 | :xmp tab=0. | |
37335 | ||
37336 | <TC - DECODING DER , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT> | |
37337 | ||
37338 | <STATIC:ASN> | |
37339 | ||
37340 | TempA | |
37341 | ||
37342 | DEFINITIONS | |
37343 | ||
37344 | EXPLICIT TAGS | |
37345 | ||
37346 | ||
37347 | ::= | |
37348 | ||
37349 | BEGIN | |
37350 | ||
37351 | ||
37352 | BERPDU ::= [0] SET | |
37353 | { | |
37354 | b BOOLEAN OPTIONAL, | |
37355 | c INTEGER OPTIONAL | |
37356 | } | |
37357 | ||
37358 | ||
37359 | END | |
37360 | ||
37361 | <STATIC> | |
37362 | ||
37363 | import from TempA all; | |
37364 | ||
37365 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37366 | ||
37367 | ||
37368 | const BERPDU myValue := {b := true, | |
37369 | c := 5 } | |
37370 | ||
37371 | ||
37372 | ||
37373 | <TTCN_TC:EXEC> | |
37374 | ||
37375 | if (dec_BER_PDU('A00831060101FF020105'O) == myValue) | |
37376 | ||
37377 | ||
37378 | ||
37379 | {setverdict(pass);} else {setverdict(fail);} | |
37380 | ||
37381 | ||
37382 | <RESULT> | |
37383 | ||
37384 | Overall verdict: pass | |
37385 | ||
37386 | <END_TC> | |
37387 | ||
37388 | :exmp. | |
37389 | ||
37390 | .*---------------------------------------------------------------------* | |
37391 | :h3. DECODING CER , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT | |
37392 | .*---------------------------------------------------------------------* | |
37393 | :xmp tab=0. | |
37394 | ||
37395 | <TC - DECODING CER , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT> | |
37396 | ||
37397 | <STATIC:ASN> | |
37398 | ||
37399 | TempA | |
37400 | ||
37401 | DEFINITIONS | |
37402 | ||
37403 | EXPLICIT TAGS | |
37404 | ||
37405 | ||
37406 | ::= | |
37407 | ||
37408 | BEGIN | |
37409 | ||
37410 | ||
37411 | BERPDU ::= [0] SET | |
37412 | { | |
37413 | b BOOLEAN OPTIONAL, | |
37414 | c INTEGER OPTIONAL | |
37415 | } | |
37416 | ||
37417 | ||
37418 | END | |
37419 | ||
37420 | <STATIC> | |
37421 | ||
37422 | import from TempA all; | |
37423 | ||
37424 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37425 | ||
37426 | ||
37427 | const BERPDU myValue := {b := true, | |
37428 | c := 5 } | |
37429 | ||
37430 | ||
37431 | ||
37432 | <TTCN_TC:EXEC> | |
37433 | ||
37434 | if (dec_BER_PDU('A08031800101FF02010500000000'O) == myValue) | |
37435 | ||
37436 | ||
37437 | ||
37438 | {setverdict(pass);} else {setverdict(fail);} | |
37439 | ||
37440 | ||
37441 | <RESULT> | |
37442 | ||
37443 | Overall verdict: pass | |
37444 | ||
37445 | <END_TC> | |
37446 | ||
37447 | :exmp. | |
37448 | ||
37449 | .*---------------------------------------------------------------------* | |
37450 | :h3. DECODING, reverse order , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT | |
37451 | .*---------------------------------------------------------------------* | |
37452 | :xmp tab=0. | |
37453 | ||
37454 | <TC - DECODING, reverse order , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT> | |
37455 | ||
37456 | <STATIC:ASN> | |
37457 | ||
37458 | TempA | |
37459 | ||
37460 | DEFINITIONS | |
37461 | ||
37462 | EXPLICIT TAGS | |
37463 | ||
37464 | ||
37465 | ::= | |
37466 | ||
37467 | BEGIN | |
37468 | ||
37469 | ||
37470 | BERPDU ::= [0] SET | |
37471 | { | |
37472 | b BOOLEAN OPTIONAL, | |
37473 | c INTEGER OPTIONAL | |
37474 | } | |
37475 | ||
37476 | ||
37477 | END | |
37478 | ||
37479 | <STATIC> | |
37480 | ||
37481 | import from TempA all; | |
37482 | ||
37483 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37484 | ||
37485 | ||
37486 | const BERPDU myValue := {b := true, | |
37487 | c := 5 } | |
37488 | ||
37489 | ||
37490 | ||
37491 | <TTCN_TC:EXEC> | |
37492 | ||
37493 | if (dec_BER_PDU('A00831060201050101FF'O) == myValue) | |
37494 | ||
37495 | ||
37496 | ||
37497 | {setverdict(pass);} else {setverdict(fail);} | |
37498 | ||
37499 | ||
37500 | <RESULT> | |
37501 | ||
37502 | Overall verdict: pass | |
37503 | ||
37504 | <END_TC> | |
37505 | ||
37506 | :exmp. | |
37507 | ||
37508 | .*---------------------------------------------------------------------* | |
37509 | :h3. DECODING, reverse order , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT | |
37510 | .*---------------------------------------------------------------------* | |
37511 | :xmp tab=0. | |
37512 | ||
37513 | <TC - DECODING, reverse order , TAGGED SET (both elements are used), EXPLICIT TAGGING ENVIRONMENT> | |
37514 | ||
37515 | <STATIC:ASN> | |
37516 | ||
37517 | TempA | |
37518 | ||
37519 | DEFINITIONS | |
37520 | ||
37521 | EXPLICIT TAGS | |
37522 | ||
37523 | ||
37524 | ::= | |
37525 | ||
37526 | BEGIN | |
37527 | ||
37528 | ||
37529 | BERPDU ::= [0] SET | |
37530 | { | |
37531 | b BOOLEAN OPTIONAL, | |
37532 | c INTEGER OPTIONAL | |
37533 | } | |
37534 | ||
37535 | ||
37536 | END | |
37537 | ||
37538 | <STATIC> | |
37539 | ||
37540 | import from TempA all; | |
37541 | ||
37542 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37543 | ||
37544 | ||
37545 | const BERPDU myValue := {b := true, | |
37546 | c := 5 } | |
37547 | ||
37548 | ||
37549 | ||
37550 | <TTCN_TC:EXEC> | |
37551 | ||
37552 | if (dec_BER_PDU('A08031800201050101FF00000000'O) == myValue) | |
37553 | ||
37554 | ||
37555 | ||
37556 | {setverdict(pass);} else {setverdict(fail);} | |
37557 | ||
37558 | ||
37559 | <RESULT> | |
37560 | ||
37561 | Overall verdict: pass | |
37562 | ||
37563 | <END_TC> | |
37564 | ||
37565 | :exmp. | |
37566 | ||
37567 | .*---------------------------------------------------------------------* | |
37568 | :h3. DECODING DER, TAGGED SET (both elements are TAGGED and used) | |
37569 | .*---------------------------------------------------------------------* | |
37570 | :xmp tab=0. | |
37571 | ||
37572 | <TC - DECODING DER, TAGGED SET (both elements are TAGGED and used)> | |
37573 | ||
37574 | <STATIC:ASN> | |
37575 | ||
37576 | TempA | |
37577 | ||
37578 | DEFINITIONS | |
37579 | ||
37580 | ||
37581 | ||
37582 | ::= | |
37583 | ||
37584 | BEGIN | |
37585 | ||
37586 | ||
37587 | BERPDU ::= [0] SET | |
37588 | { | |
37589 | b [0] BOOLEAN OPTIONAL, | |
37590 | c [1] INTEGER OPTIONAL | |
37591 | } | |
37592 | ||
37593 | ||
37594 | ||
37595 | END | |
37596 | ||
37597 | <STATIC> | |
37598 | ||
37599 | import from TempA all; | |
37600 | ||
37601 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37602 | ||
37603 | ||
37604 | const BERPDU myValue := {b := true, | |
37605 | c := 5 } | |
37606 | ||
37607 | ||
37608 | ||
37609 | <TTCN_TC:EXEC> | |
37610 | ||
37611 | if (dec_BER_PDU('A00C310AA0030101FFA103020105'O) == myValue) | |
37612 | ||
37613 | ||
37614 | ||
37615 | {setverdict(pass);} else {setverdict(fail);} | |
37616 | ||
37617 | ||
37618 | <RESULT> | |
37619 | ||
37620 | Overall verdict: pass | |
37621 | ||
37622 | <END_TC> | |
37623 | ||
37624 | :exmp. | |
37625 | ||
37626 | .*---------------------------------------------------------------------* | |
37627 | :h3. DECODING CER, TAGGED SET (both elements are TAGGED and used) | |
37628 | .*---------------------------------------------------------------------* | |
37629 | :xmp tab=0. | |
37630 | ||
37631 | <TC - DECODING CER, TAGGED SET (both elements are TAGGED and used)> | |
37632 | ||
37633 | <STATIC:ASN> | |
37634 | ||
37635 | TempA | |
37636 | ||
37637 | DEFINITIONS | |
37638 | ||
37639 | ||
37640 | ||
37641 | ::= | |
37642 | ||
37643 | BEGIN | |
37644 | ||
37645 | ||
37646 | BERPDU ::= [0] SET | |
37647 | { | |
37648 | b [0] BOOLEAN OPTIONAL, | |
37649 | c [1] INTEGER OPTIONAL | |
37650 | } | |
37651 | ||
37652 | ||
37653 | ||
37654 | END | |
37655 | ||
37656 | <STATIC> | |
37657 | ||
37658 | import from TempA all; | |
37659 | ||
37660 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37661 | ||
37662 | ||
37663 | const BERPDU myValue := {b := true, | |
37664 | c := 5 } | |
37665 | ||
37666 | ||
37667 | ||
37668 | <TTCN_TC:EXEC> | |
37669 | ||
37670 | if (dec_BER_PDU('A0803180A0800101FF0000A180020105000000000000'O) == myValue) | |
37671 | ||
37672 | ||
37673 | ||
37674 | {setverdict(pass);} else {setverdict(fail);} | |
37675 | ||
37676 | ||
37677 | <RESULT> | |
37678 | ||
37679 | Overall verdict: pass | |
37680 | ||
37681 | <END_TC> | |
37682 | ||
37683 | :exmp. | |
37684 | ||
37685 | .*---------------------------------------------------------------------* | |
37686 | :h3. DECODING reverse order, TAGGED SET (both elements are TAGGED and used) | |
37687 | .*---------------------------------------------------------------------* | |
37688 | :xmp tab=0. | |
37689 | ||
37690 | <TC - DECODING reverse order, TAGGED SET (both elements are TAGGED and used)> | |
37691 | ||
37692 | <STATIC:ASN> | |
37693 | ||
37694 | TempA | |
37695 | ||
37696 | DEFINITIONS | |
37697 | ||
37698 | ||
37699 | ||
37700 | ::= | |
37701 | ||
37702 | BEGIN | |
37703 | ||
37704 | ||
37705 | BERPDU ::= [0] SET | |
37706 | { | |
37707 | b [0] BOOLEAN OPTIONAL, | |
37708 | c [1] INTEGER OPTIONAL | |
37709 | } | |
37710 | ||
37711 | ||
37712 | ||
37713 | END | |
37714 | ||
37715 | <STATIC> | |
37716 | ||
37717 | import from TempA all; | |
37718 | ||
37719 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37720 | ||
37721 | ||
37722 | const BERPDU myValue := {b := true, | |
37723 | c := 5 } | |
37724 | ||
37725 | ||
37726 | ||
37727 | <TTCN_TC:EXEC> | |
37728 | ||
37729 | if (dec_BER_PDU('A00C310AA103020105A0030101FF'O) == myValue) | |
37730 | ||
37731 | ||
37732 | ||
37733 | {setverdict(pass);} else {setverdict(fail);} | |
37734 | ||
37735 | ||
37736 | <RESULT> | |
37737 | ||
37738 | Overall verdict: pass | |
37739 | ||
37740 | <END_TC> | |
37741 | ||
37742 | :exmp. | |
37743 | ||
37744 | .*---------------------------------------------------------------------* | |
37745 | :h3. DECODING reverse order, TAGGED SET (both elements are TAGGED and used) | |
37746 | .*---------------------------------------------------------------------* | |
37747 | :xmp tab=0. | |
37748 | ||
37749 | <TC - DECODING reverse order, TAGGED SET (both elements are TAGGED and used)> | |
37750 | ||
37751 | <STATIC:ASN> | |
37752 | ||
37753 | TempA | |
37754 | ||
37755 | DEFINITIONS | |
37756 | ||
37757 | ||
37758 | ||
37759 | ::= | |
37760 | ||
37761 | BEGIN | |
37762 | ||
37763 | ||
37764 | BERPDU ::= [0] SET | |
37765 | { | |
37766 | b [0] BOOLEAN OPTIONAL, | |
37767 | c [1] INTEGER OPTIONAL | |
37768 | } | |
37769 | ||
37770 | ||
37771 | ||
37772 | END | |
37773 | ||
37774 | <STATIC> | |
37775 | ||
37776 | import from TempA all; | |
37777 | ||
37778 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37779 | ||
37780 | ||
37781 | const BERPDU myValue := {b := true, | |
37782 | c := 5 } | |
37783 | ||
37784 | ||
37785 | ||
37786 | <TTCN_TC:EXEC> | |
37787 | ||
37788 | if (dec_BER_PDU('A0803180A1800201050000A0800101FF000000000000'O) == myValue) | |
37789 | ||
37790 | ||
37791 | ||
37792 | {setverdict(pass);} else {setverdict(fail);} | |
37793 | ||
37794 | ||
37795 | <RESULT> | |
37796 | ||
37797 | Overall verdict: pass | |
37798 | ||
37799 | <END_TC> | |
37800 | ||
37801 | :exmp. | |
37802 | ||
37803 | .*---------------------------------------------------------------------* | |
37804 | :h3. DECODING DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT | |
37805 | .*---------------------------------------------------------------------* | |
37806 | :xmp tab=0. | |
37807 | ||
37808 | <TC - DECODING DER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT> | |
37809 | ||
37810 | <STATIC:ASN> | |
37811 | ||
37812 | TempA | |
37813 | ||
37814 | DEFINITIONS | |
37815 | ||
37816 | EXPLICIT TAGS | |
37817 | ||
37818 | ||
37819 | ::= | |
37820 | ||
37821 | BEGIN | |
37822 | ||
37823 | ||
37824 | BERPDU ::= [0] SET | |
37825 | { | |
37826 | b [0] BOOLEAN OPTIONAL, | |
37827 | c [1] INTEGER OPTIONAL | |
37828 | } | |
37829 | ||
37830 | ||
37831 | END | |
37832 | ||
37833 | <STATIC> | |
37834 | ||
37835 | import from TempA all; | |
37836 | ||
37837 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37838 | ||
37839 | ||
37840 | const BERPDU myValue := {b := true, | |
37841 | c := 5 } | |
37842 | ||
37843 | ||
37844 | ||
37845 | <TTCN_TC:EXEC> | |
37846 | ||
37847 | if (dec_BER_PDU('A00C310AA0030101FFA103020105'O) == myValue) | |
37848 | ||
37849 | ||
37850 | ||
37851 | {setverdict(pass);} else {setverdict(fail);} | |
37852 | ||
37853 | ||
37854 | <RESULT> | |
37855 | ||
37856 | Overall verdict: pass | |
37857 | ||
37858 | <END_TC> | |
37859 | ||
37860 | :exmp. | |
37861 | ||
37862 | .*---------------------------------------------------------------------* | |
37863 | :h3. DECODING CER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT | |
37864 | .*---------------------------------------------------------------------* | |
37865 | :xmp tab=0. | |
37866 | ||
37867 | <TC - DECODING CER encoding of TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT> | |
37868 | ||
37869 | <STATIC:ASN> | |
37870 | ||
37871 | TempA | |
37872 | ||
37873 | DEFINITIONS | |
37874 | ||
37875 | EXPLICIT TAGS | |
37876 | ||
37877 | ||
37878 | ::= | |
37879 | ||
37880 | BEGIN | |
37881 | ||
37882 | ||
37883 | BERPDU ::= [0] SET | |
37884 | { | |
37885 | b [0] BOOLEAN OPTIONAL, | |
37886 | c [1] INTEGER OPTIONAL | |
37887 | } | |
37888 | ||
37889 | ||
37890 | END | |
37891 | ||
37892 | <STATIC> | |
37893 | ||
37894 | import from TempA all; | |
37895 | ||
37896 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37897 | ||
37898 | ||
37899 | const BERPDU myValue := {b := true, | |
37900 | c := 5 } | |
37901 | ||
37902 | ||
37903 | ||
37904 | <TTCN_TC:EXEC> | |
37905 | ||
37906 | if (dec_BER_PDU('A0803180A0800101FF0000A180020105000000000000'O) == myValue) | |
37907 | ||
37908 | ||
37909 | ||
37910 | {setverdict(pass);} else {setverdict(fail);} | |
37911 | ||
37912 | ||
37913 | <RESULT> | |
37914 | ||
37915 | Overall verdict: pass | |
37916 | ||
37917 | <END_TC> | |
37918 | ||
37919 | :exmp. | |
37920 | ||
37921 | .*---------------------------------------------------------------------* | |
37922 | :h3. DECODING ,reverse order, TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT | |
37923 | .*---------------------------------------------------------------------* | |
37924 | :xmp tab=0. | |
37925 | ||
37926 | <TC - DECODING ,reverse order, TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT> | |
37927 | ||
37928 | <STATIC:ASN> | |
37929 | ||
37930 | TempA | |
37931 | ||
37932 | DEFINITIONS | |
37933 | ||
37934 | EXPLICIT TAGS | |
37935 | ||
37936 | ||
37937 | ::= | |
37938 | ||
37939 | BEGIN | |
37940 | ||
37941 | ||
37942 | BERPDU ::= [0] SET | |
37943 | { | |
37944 | b [0] BOOLEAN OPTIONAL, | |
37945 | c [1] INTEGER OPTIONAL | |
37946 | } | |
37947 | ||
37948 | ||
37949 | END | |
37950 | ||
37951 | <STATIC> | |
37952 | ||
37953 | import from TempA all; | |
37954 | ||
37955 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
37956 | ||
37957 | ||
37958 | const BERPDU myValue := {b := true, | |
37959 | c := 5 } | |
37960 | ||
37961 | ||
37962 | ||
37963 | <TTCN_TC:EXEC> | |
37964 | ||
37965 | if (dec_BER_PDU('A00C310AA103020105A0030101FF'O) == myValue) | |
37966 | ||
37967 | ||
37968 | ||
37969 | {setverdict(pass);} else {setverdict(fail);} | |
37970 | ||
37971 | ||
37972 | <RESULT> | |
37973 | ||
37974 | Overall verdict: pass | |
37975 | ||
37976 | <END_TC> | |
37977 | ||
37978 | :exmp. | |
37979 | ||
37980 | .*---------------------------------------------------------------------* | |
37981 | :h3. DECODING, reverse order, TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT | |
37982 | .*---------------------------------------------------------------------* | |
37983 | :xmp tab=0. | |
37984 | ||
37985 | <TC - DECODING, reverse order, TAGGED SET (both elements are TAGGED and used), EXPLICIT TAGGING ENVIRONMENT> | |
37986 | ||
37987 | <STATIC:ASN> | |
37988 | ||
37989 | TempA | |
37990 | ||
37991 | DEFINITIONS | |
37992 | ||
37993 | EXPLICIT TAGS | |
37994 | ||
37995 | ||
37996 | ::= | |
37997 | ||
37998 | BEGIN | |
37999 | ||
38000 | ||
38001 | BERPDU ::= [0] SET | |
38002 | { | |
38003 | b [0] BOOLEAN OPTIONAL, | |
38004 | c [1] INTEGER OPTIONAL | |
38005 | } | |
38006 | ||
38007 | ||
38008 | END | |
38009 | ||
38010 | <STATIC> | |
38011 | ||
38012 | import from TempA all; | |
38013 | ||
38014 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38015 | ||
38016 | ||
38017 | const BERPDU myValue := {b := true, | |
38018 | c := 5 } | |
38019 | ||
38020 | ||
38021 | ||
38022 | <TTCN_TC:EXEC> | |
38023 | ||
38024 | if (dec_BER_PDU('A0803180A1800201050000A0800101FF000000000000'O) == myValue) | |
38025 | ||
38026 | ||
38027 | ||
38028 | {setverdict(pass);} else {setverdict(fail);} | |
38029 | ||
38030 | ||
38031 | <RESULT> | |
38032 | ||
38033 | Overall verdict: pass | |
38034 | ||
38035 | <END_TC> | |
38036 | ||
38037 | :exmp. | |
38038 | ||
38039 | .*---------------------------------------------------------------------* | |
38040 | :h3. DECODING , DER , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT | |
38041 | .*---------------------------------------------------------------------* | |
38042 | :xmp tab=0. | |
38043 | ||
38044 | <TC - DECODING , DER , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT> | |
38045 | ||
38046 | <STATIC:ASN> | |
38047 | ||
38048 | TempA | |
38049 | ||
38050 | DEFINITIONS | |
38051 | ||
38052 | IMPLICIT TAGS | |
38053 | ||
38054 | ||
38055 | ::= | |
38056 | ||
38057 | BEGIN | |
38058 | ||
38059 | ||
38060 | BERPDU ::= [0] SET | |
38061 | { | |
38062 | b [0] BOOLEAN OPTIONAL, | |
38063 | c [1] INTEGER OPTIONAL | |
38064 | } | |
38065 | ||
38066 | ||
38067 | END | |
38068 | ||
38069 | <STATIC> | |
38070 | ||
38071 | import from TempA all; | |
38072 | ||
38073 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38074 | ||
38075 | ||
38076 | const BERPDU myValue := {b := true, | |
38077 | c := 5 } | |
38078 | ||
38079 | ||
38080 | <TTCN_TC:EXEC> | |
38081 | ||
38082 | if (dec_BER_PDU('A0068001FF810105'O) == myValue) | |
38083 | ||
38084 | ||
38085 | ||
38086 | {setverdict(pass);} else {setverdict(fail);} | |
38087 | ||
38088 | ||
38089 | <RESULT> | |
38090 | ||
38091 | Overall verdict: pass | |
38092 | ||
38093 | <END_TC> | |
38094 | ||
38095 | :exmp. | |
38096 | ||
38097 | .*---------------------------------------------------------------------* | |
38098 | :h3. DECODING , CER , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT | |
38099 | .*---------------------------------------------------------------------* | |
38100 | :xmp tab=0. | |
38101 | ||
38102 | <TC - DECODING , CER , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT> | |
38103 | ||
38104 | <STATIC:ASN> | |
38105 | ||
38106 | TempA | |
38107 | ||
38108 | DEFINITIONS | |
38109 | ||
38110 | IMPLICIT TAGS | |
38111 | ||
38112 | ||
38113 | ::= | |
38114 | ||
38115 | BEGIN | |
38116 | ||
38117 | ||
38118 | BERPDU ::= [0] SET | |
38119 | { | |
38120 | b [0] BOOLEAN OPTIONAL, | |
38121 | c [1] INTEGER OPTIONAL | |
38122 | } | |
38123 | ||
38124 | ||
38125 | END | |
38126 | ||
38127 | <STATIC> | |
38128 | ||
38129 | import from TempA all; | |
38130 | ||
38131 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38132 | ||
38133 | ||
38134 | const BERPDU myValue := {b := true, | |
38135 | c := 5 } | |
38136 | ||
38137 | ||
38138 | <TTCN_TC:EXEC> | |
38139 | ||
38140 | if (dec_BER_PDU('A0808001FF8101050000'O) == myValue) | |
38141 | ||
38142 | ||
38143 | ||
38144 | {setverdict(pass);} else {setverdict(fail);} | |
38145 | ||
38146 | ||
38147 | <RESULT> | |
38148 | ||
38149 | Overall verdict: pass | |
38150 | ||
38151 | <END_TC> | |
38152 | ||
38153 | :exmp. | |
38154 | ||
38155 | .*---------------------------------------------------------------------* | |
38156 | :h3. DECODING , reverse order, TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT | |
38157 | .*---------------------------------------------------------------------* | |
38158 | :xmp tab=0. | |
38159 | ||
38160 | <TC - DECODING , reverse order, TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT> | |
38161 | ||
38162 | <STATIC:ASN> | |
38163 | ||
38164 | TempA | |
38165 | ||
38166 | DEFINITIONS | |
38167 | ||
38168 | IMPLICIT TAGS | |
38169 | ||
38170 | ||
38171 | ::= | |
38172 | ||
38173 | BEGIN | |
38174 | ||
38175 | ||
38176 | BERPDU ::= [0] SET | |
38177 | { | |
38178 | b [0] BOOLEAN OPTIONAL, | |
38179 | c [1] INTEGER OPTIONAL | |
38180 | } | |
38181 | ||
38182 | ||
38183 | END | |
38184 | ||
38185 | <STATIC> | |
38186 | ||
38187 | import from TempA all; | |
38188 | ||
38189 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38190 | ||
38191 | ||
38192 | const BERPDU myValue := {b := true, | |
38193 | c := 5 } | |
38194 | ||
38195 | ||
38196 | <TTCN_TC:EXEC> | |
38197 | ||
38198 | if (dec_BER_PDU('A0068101058001FF'O) == myValue) | |
38199 | ||
38200 | ||
38201 | ||
38202 | {setverdict(pass);} else {setverdict(fail);} | |
38203 | ||
38204 | ||
38205 | <RESULT> | |
38206 | ||
38207 | Overall verdict: pass | |
38208 | ||
38209 | <END_TC> | |
38210 | ||
38211 | :exmp. | |
38212 | ||
38213 | .*---------------------------------------------------------------------* | |
38214 | :h3. DECODING , reverse order , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT | |
38215 | .*---------------------------------------------------------------------* | |
38216 | :xmp tab=0. | |
38217 | ||
38218 | <TC - DECODING , reverse order , TAGGED SET (both elements are TAGGED and used), IMPLICIT TAGGING ENVIRONMENT> | |
38219 | ||
38220 | <STATIC:ASN> | |
38221 | ||
38222 | TempA | |
38223 | ||
38224 | DEFINITIONS | |
38225 | ||
38226 | IMPLICIT TAGS | |
38227 | ||
38228 | ||
38229 | ::= | |
38230 | ||
38231 | BEGIN | |
38232 | ||
38233 | ||
38234 | BERPDU ::= [0] SET | |
38235 | { | |
38236 | b [0] BOOLEAN OPTIONAL, | |
38237 | c [1] INTEGER OPTIONAL | |
38238 | } | |
38239 | ||
38240 | ||
38241 | END | |
38242 | ||
38243 | <STATIC> | |
38244 | ||
38245 | import from TempA all; | |
38246 | ||
38247 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38248 | ||
38249 | ||
38250 | const BERPDU myValue := {b := true, | |
38251 | c := 5 } | |
38252 | ||
38253 | ||
38254 | <TTCN_TC:EXEC> | |
38255 | ||
38256 | if (dec_BER_PDU('A0808101058001FF0000'O) == myValue) | |
38257 | ||
38258 | ||
38259 | ||
38260 | {setverdict(pass);} else {setverdict(fail);} | |
38261 | ||
38262 | ||
38263 | <RESULT> | |
38264 | ||
38265 | Overall verdict: pass | |
38266 | ||
38267 | <END_TC> | |
38268 | ||
38269 | :exmp. | |
38270 | ||
38271 | .*---------------------------------------------------------------------* | |
38272 | :h3. DECODING , DER , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT | |
38273 | .*---------------------------------------------------------------------* | |
38274 | :xmp tab=0. | |
38275 | ||
38276 | <TC - DECODING , DER , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT> | |
38277 | ||
38278 | <STATIC:ASN> | |
38279 | ||
38280 | TempA | |
38281 | ||
38282 | DEFINITIONS | |
38283 | ||
38284 | AUTOMATIC TAGS | |
38285 | ||
38286 | ||
38287 | ::= | |
38288 | ||
38289 | BEGIN | |
38290 | ||
38291 | ||
38292 | BERPDU ::= [0] SET | |
38293 | { | |
38294 | b [0] BOOLEAN OPTIONAL, | |
38295 | c [1] INTEGER OPTIONAL | |
38296 | } | |
38297 | ||
38298 | ||
38299 | END | |
38300 | ||
38301 | <STATIC> | |
38302 | ||
38303 | import from TempA all; | |
38304 | ||
38305 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38306 | ||
38307 | ||
38308 | const BERPDU myValue := {b := true, | |
38309 | c := 5 } | |
38310 | ||
38311 | ||
38312 | <TTCN_TC:EXEC> | |
38313 | ||
38314 | if (dec_BER_PDU('A0068001FF810105'O) == myValue) | |
38315 | ||
38316 | ||
38317 | ||
38318 | {setverdict(pass);} else {setverdict(fail);} | |
38319 | ||
38320 | ||
38321 | <RESULT> | |
38322 | ||
38323 | Overall verdict: pass | |
38324 | ||
38325 | <END_TC> | |
38326 | ||
38327 | :exmp. | |
38328 | ||
38329 | .*---------------------------------------------------------------------* | |
38330 | :h3. DECODING , CER , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT | |
38331 | .*---------------------------------------------------------------------* | |
38332 | :xmp tab=0. | |
38333 | ||
38334 | <TC - DECODING , CER , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT> | |
38335 | ||
38336 | <STATIC:ASN> | |
38337 | ||
38338 | TempA | |
38339 | ||
38340 | DEFINITIONS | |
38341 | ||
38342 | AUTOMATIC TAGS | |
38343 | ||
38344 | ||
38345 | ::= | |
38346 | ||
38347 | BEGIN | |
38348 | ||
38349 | ||
38350 | BERPDU ::= [0] SET | |
38351 | { | |
38352 | b [0] BOOLEAN OPTIONAL, | |
38353 | c [1] INTEGER OPTIONAL | |
38354 | } | |
38355 | ||
38356 | ||
38357 | END | |
38358 | ||
38359 | <STATIC> | |
38360 | ||
38361 | import from TempA all; | |
38362 | ||
38363 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38364 | ||
38365 | ||
38366 | const BERPDU myValue := {b := true, | |
38367 | c := 5 } | |
38368 | ||
38369 | ||
38370 | <TTCN_TC:EXEC> | |
38371 | ||
38372 | if (dec_BER_PDU('A0808001FF8101050000'O) == myValue) | |
38373 | ||
38374 | ||
38375 | ||
38376 | {setverdict(pass);} else {setverdict(fail);} | |
38377 | ||
38378 | ||
38379 | <RESULT> | |
38380 | ||
38381 | Overall verdict: pass | |
38382 | ||
38383 | <END_TC> | |
38384 | ||
38385 | :exmp. | |
38386 | ||
38387 | .*---------------------------------------------------------------------* | |
38388 | :h3. DECODING , reverse order , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT | |
38389 | .*---------------------------------------------------------------------* | |
38390 | :xmp tab=0. | |
38391 | ||
38392 | <TC - DECODING , reverse order , TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT> | |
38393 | ||
38394 | <STATIC:ASN> | |
38395 | ||
38396 | TempA | |
38397 | ||
38398 | DEFINITIONS | |
38399 | ||
38400 | AUTOMATIC TAGS | |
38401 | ||
38402 | ||
38403 | ::= | |
38404 | ||
38405 | BEGIN | |
38406 | ||
38407 | ||
38408 | BERPDU ::= [0] SET | |
38409 | { | |
38410 | b [0] BOOLEAN OPTIONAL, | |
38411 | c [1] INTEGER OPTIONAL | |
38412 | } | |
38413 | ||
38414 | ||
38415 | END | |
38416 | ||
38417 | <STATIC> | |
38418 | ||
38419 | import from TempA all; | |
38420 | ||
38421 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38422 | ||
38423 | ||
38424 | const BERPDU myValue := {b := true, | |
38425 | c := 5 } | |
38426 | ||
38427 | ||
38428 | <TTCN_TC:EXEC> | |
38429 | ||
38430 | if (dec_BER_PDU('A0068101058001FF'O) == myValue) | |
38431 | ||
38432 | ||
38433 | ||
38434 | {setverdict(pass);} else {setverdict(fail);} | |
38435 | ||
38436 | ||
38437 | <RESULT> | |
38438 | ||
38439 | Overall verdict: pass | |
38440 | ||
38441 | <END_TC> | |
38442 | ||
38443 | :exmp. | |
38444 | ||
38445 | .*---------------------------------------------------------------------* | |
38446 | :h3. DECODING , reverse order, TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT | |
38447 | .*---------------------------------------------------------------------* | |
38448 | :xmp tab=0. | |
38449 | ||
38450 | <TC - DECODING , reverse order, TAGGED SET (both elements are TAGGED and used), AUTOMATIC TAGGING ENVIRONMENT> | |
38451 | ||
38452 | <STATIC:ASN> | |
38453 | ||
38454 | TempA | |
38455 | ||
38456 | DEFINITIONS | |
38457 | ||
38458 | AUTOMATIC TAGS | |
38459 | ||
38460 | ||
38461 | ::= | |
38462 | ||
38463 | BEGIN | |
38464 | ||
38465 | ||
38466 | BERPDU ::= [0] SET | |
38467 | { | |
38468 | b [0] BOOLEAN OPTIONAL, | |
38469 | c [1] INTEGER OPTIONAL | |
38470 | } | |
38471 | ||
38472 | ||
38473 | END | |
38474 | ||
38475 | <STATIC> | |
38476 | ||
38477 | import from TempA all; | |
38478 | ||
38479 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38480 | ||
38481 | ||
38482 | const BERPDU myValue := {b := true, | |
38483 | c := 5 } | |
38484 | ||
38485 | ||
38486 | <TTCN_TC:EXEC> | |
38487 | ||
38488 | if (dec_BER_PDU('A0808101058001FF0000'O) == myValue) | |
38489 | ||
38490 | ||
38491 | ||
38492 | {setverdict(pass);} else {setverdict(fail);} | |
38493 | ||
38494 | ||
38495 | <RESULT> | |
38496 | ||
38497 | Overall verdict: pass | |
38498 | ||
38499 | <END_TC> | |
38500 | ||
38501 | :exmp. | |
38502 | ||
38503 | .*---------------------------------------------------------------------* | |
38504 | :h3. DECODING ,DER, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT | |
38505 | .*---------------------------------------------------------------------* | |
38506 | :xmp tab=0. | |
38507 | ||
38508 | <TC - DECODING ,DER, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT> | |
38509 | ||
38510 | <STATIC:ASN> | |
38511 | ||
38512 | TempA | |
38513 | ||
38514 | DEFINITIONS | |
38515 | ||
38516 | AUTOMATIC TAGS | |
38517 | ||
38518 | ||
38519 | ::= | |
38520 | ||
38521 | BEGIN | |
38522 | ||
38523 | ||
38524 | BERPDU ::= SET | |
38525 | { | |
38526 | b [5] BOOLEAN OPTIONAL, | |
38527 | c INTEGER OPTIONAL | |
38528 | } | |
38529 | ||
38530 | ||
38531 | END | |
38532 | ||
38533 | <STATIC> | |
38534 | ||
38535 | import from TempA all; | |
38536 | ||
38537 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38538 | ||
38539 | ||
38540 | const BERPDU myValue := {b := true, | |
38541 | c := 5 } | |
38542 | ||
38543 | ||
38544 | <TTCN_TC:EXEC> | |
38545 | ||
38546 | if (dec_BER_PDU('31060201058501FF'O) == myValue) | |
38547 | ||
38548 | ||
38549 | ||
38550 | {setverdict(pass);} else {setverdict(fail);} | |
38551 | ||
38552 | ||
38553 | <RESULT> | |
38554 | ||
38555 | Overall verdict: pass | |
38556 | ||
38557 | <END_TC> | |
38558 | ||
38559 | :exmp. | |
38560 | ||
38561 | .*---------------------------------------------------------------------* | |
38562 | :h3. DECODING ,CER, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT | |
38563 | .*---------------------------------------------------------------------* | |
38564 | :xmp tab=0. | |
38565 | ||
38566 | <TC - DECODING ,CER, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT> | |
38567 | ||
38568 | <STATIC:ASN> | |
38569 | ||
38570 | TempA | |
38571 | ||
38572 | DEFINITIONS | |
38573 | ||
38574 | AUTOMATIC TAGS | |
38575 | ||
38576 | ||
38577 | ::= | |
38578 | ||
38579 | BEGIN | |
38580 | ||
38581 | ||
38582 | BERPDU ::= SET | |
38583 | { | |
38584 | b [5] BOOLEAN OPTIONAL, | |
38585 | c INTEGER OPTIONAL | |
38586 | } | |
38587 | ||
38588 | ||
38589 | END | |
38590 | ||
38591 | <STATIC> | |
38592 | ||
38593 | import from TempA all; | |
38594 | ||
38595 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38596 | ||
38597 | ||
38598 | const BERPDU myValue := {b := true, | |
38599 | c := 5 } | |
38600 | ||
38601 | ||
38602 | <TTCN_TC:EXEC> | |
38603 | ||
38604 | if (dec_BER_PDU('31800201058501FF0000'O) == myValue) | |
38605 | ||
38606 | ||
38607 | ||
38608 | {setverdict(pass);} else {setverdict(fail);} | |
38609 | ||
38610 | ||
38611 | <RESULT> | |
38612 | ||
38613 | Overall verdict: pass | |
38614 | ||
38615 | <END_TC> | |
38616 | ||
38617 | :exmp. | |
38618 | ||
38619 | .*---------------------------------------------------------------------* | |
38620 | :h3. DECODING ,reverse order, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT | |
38621 | .*---------------------------------------------------------------------* | |
38622 | :xmp tab=0. | |
38623 | ||
38624 | <TC - DECODING ,reverse order, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT> | |
38625 | ||
38626 | <STATIC:ASN> | |
38627 | ||
38628 | TempA | |
38629 | ||
38630 | DEFINITIONS | |
38631 | ||
38632 | AUTOMATIC TAGS | |
38633 | ||
38634 | ||
38635 | ::= | |
38636 | ||
38637 | BEGIN | |
38638 | ||
38639 | ||
38640 | BERPDU ::= SET | |
38641 | { | |
38642 | b [5] BOOLEAN OPTIONAL, | |
38643 | c INTEGER OPTIONAL | |
38644 | } | |
38645 | ||
38646 | ||
38647 | END | |
38648 | ||
38649 | <STATIC> | |
38650 | ||
38651 | import from TempA all; | |
38652 | ||
38653 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38654 | ||
38655 | ||
38656 | const BERPDU myValue := {b := true, | |
38657 | c := 5 } | |
38658 | ||
38659 | ||
38660 | <TTCN_TC:EXEC> | |
38661 | ||
38662 | if (dec_BER_PDU('31068501FF020105'O) == myValue) | |
38663 | ||
38664 | ||
38665 | ||
38666 | {setverdict(pass);} else {setverdict(fail);} | |
38667 | ||
38668 | ||
38669 | <RESULT> | |
38670 | ||
38671 | Overall verdict: pass | |
38672 | ||
38673 | <END_TC> | |
38674 | ||
38675 | :exmp. | |
38676 | ||
38677 | .*---------------------------------------------------------------------* | |
38678 | :h3. DECODING ,reverse order, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT | |
38679 | .*---------------------------------------------------------------------* | |
38680 | :xmp tab=0. | |
38681 | ||
38682 | <TC - DECODING ,reverse order, SET , one element is manually tagged, AUTOMATIC TAGGING ENVIRONMENT> | |
38683 | ||
38684 | <STATIC:ASN> | |
38685 | ||
38686 | TempA | |
38687 | ||
38688 | DEFINITIONS | |
38689 | ||
38690 | AUTOMATIC TAGS | |
38691 | ||
38692 | ||
38693 | ::= | |
38694 | ||
38695 | BEGIN | |
38696 | ||
38697 | ||
38698 | BERPDU ::= SET | |
38699 | { | |
38700 | b [5] BOOLEAN OPTIONAL, | |
38701 | c INTEGER OPTIONAL | |
38702 | } | |
38703 | ||
38704 | ||
38705 | END | |
38706 | ||
38707 | <STATIC> | |
38708 | ||
38709 | import from TempA all; | |
38710 | ||
38711 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38712 | ||
38713 | ||
38714 | const BERPDU myValue := {b := true, | |
38715 | c := 5 } | |
38716 | ||
38717 | ||
38718 | <TTCN_TC:EXEC> | |
38719 | ||
38720 | if (dec_BER_PDU('31808501FF0201050000'O) == myValue) | |
38721 | ||
38722 | ||
38723 | ||
38724 | {setverdict(pass);} else {setverdict(fail);} | |
38725 | ||
38726 | ||
38727 | <RESULT> | |
38728 | ||
38729 | Overall verdict: pass | |
38730 | ||
38731 | <END_TC> | |
38732 | ||
38733 | :exmp. | |
38734 | ||
38735 | .*---------------------------------------------------------------------* | |
38736 | :h3. DECODING ,DER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags | |
38737 | .*---------------------------------------------------------------------* | |
38738 | :xmp tab=0. | |
38739 | ||
38740 | <TC - DECODING ,DER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags> | |
38741 | ||
38742 | <STATIC:ASN> | |
38743 | ||
38744 | TempA | |
38745 | ||
38746 | DEFINITIONS | |
38747 | ||
38748 | AUTOMATIC TAGS | |
38749 | ||
38750 | ||
38751 | ::= | |
38752 | ||
38753 | BEGIN | |
38754 | ||
38755 | MySeq ::= SET | |
38756 | {x INTEGER OPTIONAL, | |
38757 | y OCTET STRING} | |
38758 | ||
38759 | ||
38760 | ||
38761 | BERPDU ::= SET | |
38762 | { | |
38763 | b BOOLEAN OPTIONAL, | |
38764 | c INTEGER OPTIONAL, | |
38765 | COMPONENTS OF MySeq | |
38766 | } | |
38767 | ||
38768 | ||
38769 | END | |
38770 | ||
38771 | <STATIC> | |
38772 | ||
38773 | import from TempA all; | |
38774 | ||
38775 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38776 | ||
38777 | ||
38778 | const BERPDU myValue := {b := true, | |
38779 | c := 5 , | |
38780 | x := 6, | |
38781 | y := 'FF'O } | |
38782 | ||
38783 | ||
38784 | ||
38785 | <TTCN_TC:EXEC> | |
38786 | ||
38787 | if (dec_BER_PDU('310C8001FF8101058201068301FF'O) == myValue) | |
38788 | ||
38789 | ||
38790 | ||
38791 | {setverdict(pass);} else {setverdict(fail);} | |
38792 | ||
38793 | ||
38794 | <RESULT> | |
38795 | ||
38796 | Overall verdict: pass | |
38797 | ||
38798 | <END_TC> | |
38799 | ||
38800 | :exmp. | |
38801 | ||
38802 | .*---------------------------------------------------------------------* | |
38803 | :h3. DECODING ,CER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags | |
38804 | .*---------------------------------------------------------------------* | |
38805 | :xmp tab=0. | |
38806 | ||
38807 | <TC - DECODING ,CER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags> | |
38808 | ||
38809 | <STATIC:ASN> | |
38810 | ||
38811 | TempA | |
38812 | ||
38813 | DEFINITIONS | |
38814 | ||
38815 | AUTOMATIC TAGS | |
38816 | ||
38817 | ||
38818 | ::= | |
38819 | ||
38820 | BEGIN | |
38821 | ||
38822 | ||
38823 | MySeq ::= SET | |
38824 | {x INTEGER OPTIONAL, | |
38825 | y OCTET STRING} | |
38826 | ||
38827 | ||
38828 | ||
38829 | BERPDU ::= SET | |
38830 | { | |
38831 | b BOOLEAN OPTIONAL, | |
38832 | c INTEGER OPTIONAL, | |
38833 | COMPONENTS OF MySeq | |
38834 | } | |
38835 | ||
38836 | ||
38837 | END | |
38838 | ||
38839 | <STATIC> | |
38840 | ||
38841 | import from TempA all; | |
38842 | ||
38843 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38844 | ||
38845 | const BERPDU myValue := {b := true, | |
38846 | c := 5 , | |
38847 | x := 6, | |
38848 | y := 'FF'O } | |
38849 | ||
38850 | ||
38851 | ||
38852 | ||
38853 | <TTCN_TC:EXEC> | |
38854 | ||
38855 | if (dec_BER_PDU('31808001FF8101058201068301FF0000'O) == myValue){setverdict(pass);} else {setverdict(fail);} | |
38856 | ||
38857 | ||
38858 | <RESULT> | |
38859 | ||
38860 | Overall verdict: pass | |
38861 | ||
38862 | <END_TC> | |
38863 | ||
38864 | :exmp. | |
38865 | ||
38866 | .*---------------------------------------------------------------------* | |
38867 | :h3. DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags | |
38868 | .*---------------------------------------------------------------------* | |
38869 | :xmp tab=0. | |
38870 | ||
38871 | <TC - DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags> | |
38872 | ||
38873 | <STATIC:ASN> | |
38874 | ||
38875 | TempA | |
38876 | ||
38877 | DEFINITIONS | |
38878 | ||
38879 | AUTOMATIC TAGS | |
38880 | ||
38881 | ||
38882 | ::= | |
38883 | ||
38884 | BEGIN | |
38885 | ||
38886 | MySeq ::= SET | |
38887 | {x INTEGER OPTIONAL, | |
38888 | y OCTET STRING} | |
38889 | ||
38890 | ||
38891 | ||
38892 | BERPDU ::= SET | |
38893 | { | |
38894 | b BOOLEAN OPTIONAL, | |
38895 | c INTEGER OPTIONAL, | |
38896 | COMPONENTS OF MySeq | |
38897 | } | |
38898 | ||
38899 | ||
38900 | END | |
38901 | ||
38902 | <STATIC> | |
38903 | ||
38904 | import from TempA all; | |
38905 | ||
38906 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38907 | ||
38908 | ||
38909 | const BERPDU myValue := {b := true, | |
38910 | c := 5 , | |
38911 | x := 6, | |
38912 | y := 'FF'O } | |
38913 | ||
38914 | ||
38915 | ||
38916 | <TTCN_TC:EXEC> | |
38917 | ||
38918 | if (dec_BER_PDU('310C8001FF8201068101058301FF'O) == myValue) | |
38919 | ||
38920 | ||
38921 | ||
38922 | {setverdict(pass);} else {setverdict(fail);} | |
38923 | ||
38924 | ||
38925 | <RESULT> | |
38926 | ||
38927 | Overall verdict: pass | |
38928 | ||
38929 | <END_TC> | |
38930 | ||
38931 | :exmp. | |
38932 | ||
38933 | .*---------------------------------------------------------------------* | |
38934 | :h3. DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags | |
38935 | .*---------------------------------------------------------------------* | |
38936 | :xmp tab=0. | |
38937 | ||
38938 | <TC - DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags> | |
38939 | ||
38940 | <STATIC:ASN> | |
38941 | ||
38942 | TempA | |
38943 | ||
38944 | DEFINITIONS | |
38945 | ||
38946 | AUTOMATIC TAGS | |
38947 | ||
38948 | ||
38949 | ::= | |
38950 | ||
38951 | BEGIN | |
38952 | ||
38953 | ||
38954 | MySeq ::= SET | |
38955 | {x INTEGER OPTIONAL, | |
38956 | y OCTET STRING} | |
38957 | ||
38958 | ||
38959 | ||
38960 | BERPDU ::= SET | |
38961 | { | |
38962 | b BOOLEAN OPTIONAL, | |
38963 | c INTEGER OPTIONAL, | |
38964 | COMPONENTS OF MySeq | |
38965 | } | |
38966 | ||
38967 | ||
38968 | END | |
38969 | ||
38970 | <STATIC> | |
38971 | ||
38972 | import from TempA all; | |
38973 | ||
38974 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
38975 | ||
38976 | const BERPDU myValue := {b := true, | |
38977 | c := 5 , | |
38978 | x := 6, | |
38979 | y := 'FF'O } | |
38980 | ||
38981 | ||
38982 | ||
38983 | ||
38984 | <TTCN_TC:EXEC> | |
38985 | ||
38986 | if (dec_BER_PDU('31808001FF8201068101058301FF0000'O) == myValue) | |
38987 | ||
38988 | ||
38989 | ||
38990 | {setverdict(pass);} else {setverdict(fail);} | |
38991 | ||
38992 | ||
38993 | <RESULT> | |
38994 | ||
38995 | Overall verdict: pass | |
38996 | ||
38997 | <END_TC> | |
38998 | ||
38999 | :exmp. | |
39000 | ||
39001 | .*---------------------------------------------------------------------* | |
39002 | :h3. DECODING ,DER, SET ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
39003 | .*---------------------------------------------------------------------* | |
39004 | :xmp tab=0. | |
39005 | ||
39006 | <TC - DECODING ,DER, SET ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
39007 | ||
39008 | <STATIC:ASN> | |
39009 | ||
39010 | TempA | |
39011 | ||
39012 | DEFINITIONS | |
39013 | ||
39014 | AUTOMATIC TAGS | |
39015 | ||
39016 | ||
39017 | ::= | |
39018 | ||
39019 | BEGIN | |
39020 | ||
39021 | MySeq ::= SET | |
39022 | {x [0] INTEGER OPTIONAL, | |
39023 | y OCTET STRING} | |
39024 | ||
39025 | ||
39026 | ||
39027 | BERPDU ::= SET | |
39028 | { | |
39029 | b BOOLEAN OPTIONAL, | |
39030 | c INTEGER OPTIONAL, | |
39031 | COMPONENTS OF MySeq | |
39032 | } | |
39033 | ||
39034 | ||
39035 | ||
39036 | END | |
39037 | ||
39038 | <STATIC> | |
39039 | ||
39040 | import from TempA all; | |
39041 | ||
39042 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
39043 | ||
39044 | ||
39045 | const BERPDU myValue := {b := true, | |
39046 | c := 5 , | |
39047 | x := 6, | |
39048 | y := 'FF'O } | |
39049 | ||
39050 | ||
39051 | ||
39052 | <TTCN_TC:EXEC> | |
39053 | ||
39054 | if (dec_BER_PDU('310C8001FF8101058201068301FF'O) == myValue) | |
39055 | ||
39056 | ||
39057 | ||
39058 | {setverdict(pass);} else {setverdict(fail);} | |
39059 | ||
39060 | ||
39061 | <RESULT> | |
39062 | ||
39063 | Overall verdict: pass | |
39064 | ||
39065 | <END_TC> | |
39066 | ||
39067 | :exmp. | |
39068 | ||
39069 | .*---------------------------------------------------------------------* | |
39070 | :h3. DECODING ,CER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags | |
39071 | .*---------------------------------------------------------------------* | |
39072 | :xmp tab=0. | |
39073 | ||
39074 | <TC - DECODING ,CER, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags> | |
39075 | ||
39076 | <STATIC:ASN> | |
39077 | ||
39078 | TempA | |
39079 | ||
39080 | DEFINITIONS | |
39081 | ||
39082 | AUTOMATIC TAGS | |
39083 | ||
39084 | ||
39085 | ::= | |
39086 | ||
39087 | BEGIN | |
39088 | ||
39089 | ||
39090 | MySeq ::= SET | |
39091 | {x [0] INTEGER OPTIONAL, | |
39092 | y OCTET STRING} | |
39093 | ||
39094 | ||
39095 | ||
39096 | BERPDU ::= SET | |
39097 | { | |
39098 | b BOOLEAN OPTIONAL, | |
39099 | c INTEGER OPTIONAL, | |
39100 | COMPONENTS OF MySeq | |
39101 | } | |
39102 | ||
39103 | ||
39104 | ||
39105 | ||
39106 | END | |
39107 | ||
39108 | <STATIC> | |
39109 | ||
39110 | import from TempA all; | |
39111 | ||
39112 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
39113 | ||
39114 | ||
39115 | const BERPDU myValue := {b := true, | |
39116 | c := 5 , | |
39117 | x := 6, | |
39118 | y := 'FF'O } | |
39119 | ||
39120 | ||
39121 | ||
39122 | <TTCN_TC:EXEC> | |
39123 | ||
39124 | if (dec_BER_PDU('31808001FF8101058201068301FF0000'O) == myValue) | |
39125 | ||
39126 | ||
39127 | ||
39128 | {setverdict(pass);} else {setverdict(fail);} | |
39129 | ||
39130 | ||
39131 | <RESULT> | |
39132 | ||
39133 | Overall verdict: pass | |
39134 | ||
39135 | <END_TC> | |
39136 | ||
39137 | :exmp. | |
39138 | ||
39139 | .*---------------------------------------------------------------------* | |
39140 | :h3. DECODING ,different order, SET ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
39141 | .*---------------------------------------------------------------------* | |
39142 | :xmp tab=0. | |
39143 | ||
39144 | <TC - DECODING ,different order, SET ,one component element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
39145 | ||
39146 | <STATIC:ASN> | |
39147 | ||
39148 | TempA | |
39149 | ||
39150 | DEFINITIONS | |
39151 | ||
39152 | AUTOMATIC TAGS | |
39153 | ||
39154 | ||
39155 | ::= | |
39156 | ||
39157 | BEGIN | |
39158 | ||
39159 | MySeq ::= SET | |
39160 | {x [0] INTEGER OPTIONAL, | |
39161 | y OCTET STRING} | |
39162 | ||
39163 | ||
39164 | ||
39165 | BERPDU ::= SET | |
39166 | { | |
39167 | b BOOLEAN OPTIONAL, | |
39168 | c INTEGER OPTIONAL, | |
39169 | COMPONENTS OF MySeq | |
39170 | } | |
39171 | ||
39172 | ||
39173 | ||
39174 | END | |
39175 | ||
39176 | <STATIC> | |
39177 | ||
39178 | import from TempA all; | |
39179 | ||
39180 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
39181 | ||
39182 | ||
39183 | const BERPDU myValue := {b := true, | |
39184 | c := 5 , | |
39185 | x := 6, | |
39186 | y := 'FF'O } | |
39187 | ||
39188 | ||
39189 | ||
39190 | <TTCN_TC:EXEC> | |
39191 | ||
39192 | if (dec_BER_PDU('310C8301FF8001FF820106810105'O) == myValue) | |
39193 | ||
39194 | ||
39195 | ||
39196 | {setverdict(pass);} else {setverdict(fail);} | |
39197 | ||
39198 | ||
39199 | <RESULT> | |
39200 | ||
39201 | Overall verdict: pass | |
39202 | ||
39203 | <END_TC> | |
39204 | ||
39205 | :exmp. | |
39206 | ||
39207 | .*---------------------------------------------------------------------* | |
39208 | :h3. DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags | |
39209 | .*---------------------------------------------------------------------* | |
39210 | :xmp tab=0. | |
39211 | ||
39212 | <TC - DECODING ,different order, SET ,COMPONENTS OF used, AUTOMATIC TAGS, no manual tags> | |
39213 | ||
39214 | <STATIC:ASN> | |
39215 | ||
39216 | TempA | |
39217 | ||
39218 | DEFINITIONS | |
39219 | ||
39220 | AUTOMATIC TAGS | |
39221 | ||
39222 | ||
39223 | ::= | |
39224 | ||
39225 | BEGIN | |
39226 | ||
39227 | ||
39228 | MySeq ::= SET | |
39229 | {x [0] INTEGER OPTIONAL, | |
39230 | y OCTET STRING} | |
39231 | ||
39232 | ||
39233 | ||
39234 | BERPDU ::= SET | |
39235 | { | |
39236 | b BOOLEAN OPTIONAL, | |
39237 | c INTEGER OPTIONAL, | |
39238 | COMPONENTS OF MySeq | |
39239 | } | |
39240 | ||
39241 | ||
39242 | ||
39243 | ||
39244 | END | |
39245 | ||
39246 | <STATIC> | |
39247 | ||
39248 | import from TempA all; | |
39249 | ||
39250 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
39251 | ||
39252 | ||
39253 | const BERPDU myValue := {b := true, | |
39254 | c := 5 , | |
39255 | x := 6, | |
39256 | y := 'FF'O } | |
39257 | ||
39258 | ||
39259 | ||
39260 | <TTCN_TC:EXEC> | |
39261 | ||
39262 | if (dec_BER_PDU('31808301FF8101058201068001FF0000'O) == myValue) | |
39263 | ||
39264 | ||
39265 | ||
39266 | {setverdict(pass);} else {setverdict(fail);} | |
39267 | ||
39268 | ||
39269 | <RESULT> | |
39270 | ||
39271 | Overall verdict: pass | |
39272 | ||
39273 | <END_TC> | |
39274 | ||
39275 | :exmp. | |
39276 | ||
39277 | .*---------------------------------------------------------------------* | |
39278 | :h3. DECODING ,DER, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
39279 | .*---------------------------------------------------------------------* | |
39280 | :xmp tab=0. | |
39281 | ||
39282 | <TC - DECODING ,DER, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
39283 | ||
39284 | <STATIC:ASN> | |
39285 | ||
39286 | TempA | |
39287 | ||
39288 | DEFINITIONS | |
39289 | ||
39290 | AUTOMATIC TAGS | |
39291 | ||
39292 | ||
39293 | ::= | |
39294 | ||
39295 | BEGIN | |
39296 | ||
39297 | ||
39298 | MySeq ::= SET | |
39299 | {x INTEGER OPTIONAL, | |
39300 | y OCTET STRING} | |
39301 | ||
39302 | ||
39303 | ||
39304 | BERPDU ::= SET | |
39305 | { | |
39306 | b [0] BOOLEAN OPTIONAL, | |
39307 | c BIT STRING OPTIONAL, | |
39308 | COMPONENTS OF MySeq | |
39309 | } | |
39310 | ||
39311 | END | |
39312 | ||
39313 | <STATIC> | |
39314 | ||
39315 | import from TempA all; | |
39316 | ||
39317 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
39318 | ||
39319 | ||
39320 | ||
39321 | const BERPDU myValue := {b := true, | |
39322 | c := '1'B , | |
39323 | x := 6, | |
39324 | y := 'FF'O } | |
39325 | ||
39326 | ||
39327 | <TTCN_TC:EXEC> | |
39328 | ||
39329 | if (dec_BER_PDU('310D020106030207800401FF8001FF'O) == myValue) | |
39330 | ||
39331 | ||
39332 | {setverdict(pass);} else {setverdict(fail);} | |
39333 | ||
39334 | ||
39335 | <RESULT> | |
39336 | ||
39337 | Overall verdict: pass | |
39338 | ||
39339 | <END_TC> | |
39340 | ||
39341 | :exmp. | |
39342 | ||
39343 | .*---------------------------------------------------------------------* | |
39344 | :h3. DECODING ,CER, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
39345 | .*---------------------------------------------------------------------* | |
39346 | :xmp tab=0. | |
39347 | ||
39348 | <TC - DECODING ,CER, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
39349 | ||
39350 | <STATIC:ASN> | |
39351 | ||
39352 | TempA | |
39353 | ||
39354 | DEFINITIONS | |
39355 | ||
39356 | AUTOMATIC TAGS | |
39357 | ||
39358 | ||
39359 | ::= | |
39360 | ||
39361 | BEGIN | |
39362 | ||
39363 | ||
39364 | MySeq ::= SET | |
39365 | {x INTEGER OPTIONAL, | |
39366 | y OCTET STRING} | |
39367 | ||
39368 | ||
39369 | ||
39370 | BERPDU ::= SET | |
39371 | { | |
39372 | b [0] BOOLEAN OPTIONAL, | |
39373 | c BIT STRING OPTIONAL, | |
39374 | COMPONENTS OF MySeq | |
39375 | } | |
39376 | ||
39377 | ||
39378 | ||
39379 | ||
39380 | END | |
39381 | ||
39382 | <STATIC> | |
39383 | ||
39384 | import from TempA all; | |
39385 | ||
39386 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
39387 | ||
39388 | ||
39389 | const BERPDU myValue := {b := true, | |
39390 | c := '1'B , | |
39391 | x := 6, | |
39392 | y := 'FF'O } | |
39393 | ||
39394 | ||
39395 | <TTCN_TC:EXEC> | |
39396 | ||
39397 | if (dec_BER_PDU('3180020106030207800401FF8001FF0000'O) == myValue) | |
39398 | ||
39399 | ||
39400 | ||
39401 | {setverdict(pass);} else {setverdict(fail);} | |
39402 | ||
39403 | ||
39404 | <RESULT> | |
39405 | ||
39406 | Overall verdict: pass | |
39407 | ||
39408 | <END_TC> | |
39409 | ||
39410 | :exmp. | |
39411 | ||
39412 | .*---------------------------------------------------------------------* | |
39413 | :h3. DECODING ,different order, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
39414 | .*---------------------------------------------------------------------* | |
39415 | :xmp tab=0. | |
39416 | ||
39417 | <TC - DECODING ,different order, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
39418 | ||
39419 | <STATIC:ASN> | |
39420 | ||
39421 | TempA | |
39422 | ||
39423 | DEFINITIONS | |
39424 | ||
39425 | AUTOMATIC TAGS | |
39426 | ||
39427 | ||
39428 | ::= | |
39429 | ||
39430 | BEGIN | |
39431 | ||
39432 | ||
39433 | MySeq ::= SET | |
39434 | {x INTEGER OPTIONAL, | |
39435 | y OCTET STRING} | |
39436 | ||
39437 | ||
39438 | ||
39439 | BERPDU ::= SET | |
39440 | { | |
39441 | b [0] BOOLEAN OPTIONAL, | |
39442 | c BIT STRING OPTIONAL, | |
39443 | COMPONENTS OF MySeq | |
39444 | } | |
39445 | ||
39446 | END | |
39447 | ||
39448 | <STATIC> | |
39449 | ||
39450 | import from TempA all; | |
39451 | ||
39452 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
39453 | ||
39454 | ||
39455 | ||
39456 | const BERPDU myValue := {b := true, | |
39457 | c := '1'B , | |
39458 | x := 6, | |
39459 | y := 'FF'O } | |
39460 | ||
39461 | ||
39462 | <TTCN_TC:EXEC> | |
39463 | ||
39464 | if (dec_BER_PDU('310D030207800201060401FF8001FF'O) == myValue) | |
39465 | ||
39466 | ||
39467 | ||
39468 | {setverdict(pass);} else {setverdict(fail);} | |
39469 | ||
39470 | ||
39471 | <RESULT> | |
39472 | ||
39473 | Overall verdict: pass | |
39474 | ||
39475 | <END_TC> | |
39476 | ||
39477 | :exmp. | |
39478 | ||
39479 | .*---------------------------------------------------------------------* | |
39480 | :h3. DECODING ,different order, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
39481 | .*---------------------------------------------------------------------* | |
39482 | :xmp tab=0. | |
39483 | ||
39484 | <TC - DECODING ,different order, SET , one base element is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
39485 | ||
39486 | <STATIC:ASN> | |
39487 | ||
39488 | TempA | |
39489 | ||
39490 | DEFINITIONS | |
39491 | ||
39492 | AUTOMATIC TAGS | |
39493 | ||
39494 | ||
39495 | ::= | |
39496 | ||
39497 | BEGIN | |
39498 | ||
39499 | ||
39500 | MySeq ::= SET | |
39501 | {x INTEGER OPTIONAL, | |
39502 | y OCTET STRING} | |
39503 | ||
39504 | ||
39505 | ||
39506 | BERPDU ::= SET | |
39507 | { | |
39508 | b [0] BOOLEAN OPTIONAL, | |
39509 | c BIT STRING OPTIONAL, | |
39510 | COMPONENTS OF MySeq | |
39511 | } | |
39512 | ||
39513 | ||
39514 | ||
39515 | ||
39516 | END | |
39517 | ||
39518 | <STATIC> | |
39519 | ||
39520 | import from TempA all; | |
39521 | ||
39522 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
39523 | ||
39524 | ||
39525 | const BERPDU myValue := {b := true, | |
39526 | c := '1'B , | |
39527 | x := 6, | |
39528 | y := 'FF'O } | |
39529 | ||
39530 | ||
39531 | <TTCN_TC:EXEC> | |
39532 | ||
39533 | if (dec_BER_PDU('3180030207800201060401FF8001FF0000'O) == myValue) | |
39534 | ||
39535 | ||
39536 | ||
39537 | {setverdict(pass);} else {setverdict(fail);} | |
39538 | ||
39539 | ||
39540 | <RESULT> | |
39541 | ||
39542 | Overall verdict: pass | |
39543 | ||
39544 | <END_TC> | |
39545 | ||
39546 | :exmp. | |
39547 | ||
39548 | .*---------------------------------------------------------------------* | |
39549 | :h3. DECODING ,DER, SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
39550 | .*---------------------------------------------------------------------* | |
39551 | :xmp tab=0. | |
39552 | ||
39553 | <TC - DECODING ,DER, SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
39554 | ||
39555 | <STATIC:ASN> | |
39556 | ||
39557 | TempA | |
39558 | ||
39559 | DEFINITIONS | |
39560 | ||
39561 | AUTOMATIC TAGS | |
39562 | ||
39563 | ||
39564 | ::= | |
39565 | ||
39566 | BEGIN | |
39567 | ||
39568 | ||
39569 | MySeq ::= SET | |
39570 | {x [1] INTEGER OPTIONAL, | |
39571 | y OCTET STRING} | |
39572 | ||
39573 | ||
39574 | ||
39575 | BERPDU ::= SET | |
39576 | { | |
39577 | b [0] BOOLEAN OPTIONAL, | |
39578 | c BIT STRING OPTIONAL, | |
39579 | COMPONENTS OF MySeq | |
39580 | } | |
39581 | ||
39582 | END | |
39583 | ||
39584 | <STATIC> | |
39585 | ||
39586 | import from TempA all; | |
39587 | ||
39588 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
39589 | ||
39590 | ||
39591 | ||
39592 | const BERPDU myValue := {b := true, | |
39593 | c := '1'B , | |
39594 | x := 6, | |
39595 | y := 'FF'O } | |
39596 | ||
39597 | ||
39598 | ||
39599 | <TTCN_TC:EXEC> | |
39600 | ||
39601 | if (dec_BER_PDU('310D030207800401FF8001FF810106'O) == myValue) | |
39602 | ||
39603 | ||
39604 | ||
39605 | {setverdict(pass);} else {setverdict(fail);} | |
39606 | ||
39607 | ||
39608 | <RESULT> | |
39609 | ||
39610 | Overall verdict: pass | |
39611 | ||
39612 | <END_TC> | |
39613 | ||
39614 | :exmp. | |
39615 | ||
39616 | .*---------------------------------------------------------------------* | |
39617 | :h3. DECODING ,CER, SET, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
39618 | .*---------------------------------------------------------------------* | |
39619 | :xmp tab=0. | |
39620 | ||
39621 | <TC - DECODING ,CER, SET, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
39622 | ||
39623 | <STATIC:ASN> | |
39624 | ||
39625 | TempA | |
39626 | ||
39627 | DEFINITIONS | |
39628 | ||
39629 | AUTOMATIC TAGS | |
39630 | ||
39631 | ||
39632 | ::= | |
39633 | ||
39634 | BEGIN | |
39635 | ||
39636 | ||
39637 | MySeq ::= SET | |
39638 | {x [1] INTEGER OPTIONAL, | |
39639 | y OCTET STRING} | |
39640 | ||
39641 | ||
39642 | ||
39643 | BERPDU ::= SET | |
39644 | { | |
39645 | b [0] BOOLEAN OPTIONAL, | |
39646 | c BIT STRING OPTIONAL, | |
39647 | COMPONENTS OF MySeq | |
39648 | } | |
39649 | ||
39650 | ||
39651 | ||
39652 | ||
39653 | END | |
39654 | ||
39655 | <STATIC> | |
39656 | ||
39657 | import from TempA all; | |
39658 | ||
39659 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
39660 | ||
39661 | ||
39662 | const BERPDU myValue := {b := true, | |
39663 | c := '1'B , | |
39664 | x := 6, | |
39665 | y := 'FF'O } | |
39666 | ||
39667 | ||
39668 | ||
39669 | <TTCN_TC:EXEC> | |
39670 | ||
39671 | if (dec_BER_PDU('3180030207800401FF8001FF8101060000'O) == myValue) | |
39672 | ||
39673 | ||
39674 | ||
39675 | {setverdict(pass);} else {setverdict(fail);} | |
39676 | ||
39677 | ||
39678 | <RESULT> | |
39679 | ||
39680 | Overall verdict: pass | |
39681 | ||
39682 | <END_TC> | |
39683 | ||
39684 | :exmp. | |
39685 | ||
39686 | .*---------------------------------------------------------------------* | |
39687 | :h3. DECODING ,different order, SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
39688 | .*---------------------------------------------------------------------* | |
39689 | :xmp tab=0. | |
39690 | ||
39691 | <TC - DECODING ,different order, SET , one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
39692 | ||
39693 | <STATIC:ASN> | |
39694 | ||
39695 | TempA | |
39696 | ||
39697 | DEFINITIONS | |
39698 | ||
39699 | AUTOMATIC TAGS | |
39700 | ||
39701 | ||
39702 | ::= | |
39703 | ||
39704 | BEGIN | |
39705 | ||
39706 | ||
39707 | MySeq ::= SET | |
39708 | {x [1] INTEGER OPTIONAL, | |
39709 | y OCTET STRING} | |
39710 | ||
39711 | ||
39712 | ||
39713 | BERPDU ::= SET | |
39714 | { | |
39715 | b [0] BOOLEAN OPTIONAL, | |
39716 | c BIT STRING OPTIONAL, | |
39717 | COMPONENTS OF MySeq | |
39718 | } | |
39719 | ||
39720 | END | |
39721 | ||
39722 | <STATIC> | |
39723 | ||
39724 | import from TempA all; | |
39725 | ||
39726 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
39727 | ||
39728 | ||
39729 | ||
39730 | const BERPDU myValue := {b := true, | |
39731 | c := '1'B , | |
39732 | x := 6, | |
39733 | y := 'FF'O } | |
39734 | ||
39735 | ||
39736 | ||
39737 | <TTCN_TC:EXEC> | |
39738 | ||
39739 | if (dec_BER_PDU('310D8101060401FF8001FF03020780'O) == myValue) | |
39740 | ||
39741 | ||
39742 | ||
39743 | {setverdict(pass);} else {setverdict(fail);} | |
39744 | ||
39745 | ||
39746 | <RESULT> | |
39747 | ||
39748 | Overall verdict: pass | |
39749 | ||
39750 | <END_TC> | |
39751 | ||
39752 | :exmp. | |
39753 | ||
39754 | .*---------------------------------------------------------------------* | |
39755 | :h3. DECODING ,different order, SET, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS | |
39756 | .*---------------------------------------------------------------------* | |
39757 | :xmp tab=0. | |
39758 | ||
39759 | <TC - DECODING ,different order, SET, one base element and one component is manually tagged,COMPONENTS OF used, AUTOMATIC TAGS> | |
39760 | ||
39761 | <STATIC:ASN> | |
39762 | ||
39763 | TempA | |
39764 | ||
39765 | DEFINITIONS | |
39766 | ||
39767 | AUTOMATIC TAGS | |
39768 | ||
39769 | ||
39770 | ::= | |
39771 | ||
39772 | BEGIN | |
39773 | ||
39774 | ||
39775 | MySeq ::= SET | |
39776 | {x [1] INTEGER OPTIONAL, | |
39777 | y OCTET STRING} | |
39778 | ||
39779 | ||
39780 | ||
39781 | BERPDU ::= SET | |
39782 | { | |
39783 | b [0] BOOLEAN OPTIONAL, | |
39784 | c BIT STRING OPTIONAL, | |
39785 | COMPONENTS OF MySeq | |
39786 | } | |
39787 | ||
39788 | ||
39789 | ||
39790 | ||
39791 | END | |
39792 | ||
39793 | <STATIC> | |
39794 | ||
39795 | import from TempA all; | |
39796 | ||
39797 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
39798 | ||
39799 | ||
39800 | const BERPDU myValue := {b := true, | |
39801 | c := '1'B , | |
39802 | x := 6, | |
39803 | y := 'FF'O } | |
39804 | ||
39805 | ||
39806 | ||
39807 | <TTCN_TC:EXEC> | |
39808 | ||
39809 | if (dec_BER_PDU('31808001FF0401FF030207808101060000'O) == myValue) | |
39810 | ||
39811 | ||
39812 | ||
39813 | {setverdict(pass);} else {setverdict(fail);} | |
39814 | ||
39815 | ||
39816 | <RESULT> | |
39817 | ||
39818 | Overall verdict: pass | |
39819 | ||
39820 | <END_TC> | |
39821 | ||
39822 | :exmp. | |
39823 | ||
39824 | .*---------------------------------------------------------------------* | |
39825 | :h3. DECODING ,DER, SET with CHOICE element, AUTOMATIC TAGS | |
39826 | .*---------------------------------------------------------------------* | |
39827 | :xmp tab=0. | |
39828 | ||
39829 | <TC - DECODING ,DER, SET with CHOICE element, AUTOMATIC TAGS> | |
39830 | ||
39831 | <STATIC:ASN> | |
39832 | ||
39833 | TempA | |
39834 | ||
39835 | DEFINITIONS | |
39836 | ||
39837 | AUTOMATIC TAGS | |
39838 | ||
39839 | ||
39840 | ::= | |
39841 | ||
39842 | BEGIN | |
39843 | ||
39844 | ||
39845 | BERPDU ::= SET | |
39846 | { | |
39847 | b CHOICE { | |
39848 | x BOOLEAN, | |
39849 | y OCTET STRING | |
39850 | } | |
39851 | OPTIONAL, | |
39852 | ||
39853 | ||
39854 | c INTEGER OPTIONAL | |
39855 | ||
39856 | } | |
39857 | ||
39858 | ||
39859 | ||
39860 | END | |
39861 | ||
39862 | <STATIC> | |
39863 | ||
39864 | import from TempA all; | |
39865 | ||
39866 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
39867 | ||
39868 | ||
39869 | const BERPDU myValue := {b := {x := true}, | |
39870 | c := 4 | |
39871 | } | |
39872 | ||
39873 | ||
39874 | ||
39875 | <TTCN_TC:EXEC> | |
39876 | ||
39877 | if (dec_BER_PDU('3108A0038001FF810104'O) == myValue) | |
39878 | ||
39879 | ||
39880 | ||
39881 | {setverdict(pass);} else {setverdict(fail);} | |
39882 | ||
39883 | ||
39884 | <RESULT> | |
39885 | ||
39886 | Overall verdict: pass | |
39887 | ||
39888 | <END_TC> | |
39889 | ||
39890 | :exmp. | |
39891 | ||
39892 | .*---------------------------------------------------------------------* | |
39893 | :h3. DECODING ,CER, SET with CHOICE element, AUTOMATIC TAGS | |
39894 | .*---------------------------------------------------------------------* | |
39895 | :xmp tab=0. | |
39896 | ||
39897 | <TC - DECODING ,CER, SET with CHOICE element, AUTOMATIC TAGS> | |
39898 | ||
39899 | <STATIC:ASN> | |
39900 | ||
39901 | TempA | |
39902 | ||
39903 | DEFINITIONS | |
39904 | ||
39905 | AUTOMATIC TAGS | |
39906 | ||
39907 | ||
39908 | ::= | |
39909 | ||
39910 | BEGIN | |
39911 | ||
39912 | BERPDU ::= SET | |
39913 | { | |
39914 | b CHOICE { | |
39915 | x BOOLEAN, | |
39916 | y OCTET STRING | |
39917 | } | |
39918 | OPTIONAL, | |
39919 | ||
39920 | ||
39921 | c INTEGER OPTIONAL | |
39922 | ||
39923 | } | |
39924 | ||
39925 | ||
39926 | END | |
39927 | ||
39928 | <STATIC> | |
39929 | ||
39930 | import from TempA all; | |
39931 | ||
39932 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
39933 | ||
39934 | ||
39935 | const BERPDU myValue := {b := {x := true}, | |
39936 | c := 4 | |
39937 | } | |
39938 | ||
39939 | ||
39940 | <TTCN_TC:EXEC> | |
39941 | ||
39942 | if (dec_BER_PDU('3180A0808001FF00008101040000'O) == myValue) | |
39943 | ||
39944 | ||
39945 | ||
39946 | {setverdict(pass);} else {setverdict(fail);} | |
39947 | ||
39948 | ||
39949 | <RESULT> | |
39950 | ||
39951 | Overall verdict: pass | |
39952 | ||
39953 | <END_TC> | |
39954 | ||
39955 | :exmp. | |
39956 | ||
39957 | .*---------------------------------------------------------------------* | |
39958 | :h3. DECODING ,reverse order, SET with CHOICE element, AUTOMATIC TAGS | |
39959 | .*---------------------------------------------------------------------* | |
39960 | :xmp tab=0. | |
39961 | ||
39962 | <TC - DECODING ,reverse order, SET with CHOICE element, AUTOMATIC TAGS> | |
39963 | ||
39964 | <STATIC:ASN> | |
39965 | ||
39966 | TempA | |
39967 | ||
39968 | DEFINITIONS | |
39969 | ||
39970 | AUTOMATIC TAGS | |
39971 | ||
39972 | ||
39973 | ::= | |
39974 | ||
39975 | BEGIN | |
39976 | ||
39977 | ||
39978 | BERPDU ::= SET | |
39979 | { | |
39980 | b CHOICE { | |
39981 | x BOOLEAN, | |
39982 | y OCTET STRING | |
39983 | } | |
39984 | OPTIONAL, | |
39985 | ||
39986 | ||
39987 | c INTEGER OPTIONAL | |
39988 | ||
39989 | } | |
39990 | ||
39991 | ||
39992 | ||
39993 | END | |
39994 | ||
39995 | <STATIC> | |
39996 | ||
39997 | import from TempA all; | |
39998 | ||
39999 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40000 | ||
40001 | ||
40002 | const BERPDU myValue := {b := {x := true}, | |
40003 | c := 4 | |
40004 | } | |
40005 | ||
40006 | ||
40007 | ||
40008 | <TTCN_TC:EXEC> | |
40009 | ||
40010 | if (dec_BER_PDU('3108810104A0038001FF'O) == myValue) | |
40011 | ||
40012 | ||
40013 | ||
40014 | {setverdict(pass);} else {setverdict(fail);} | |
40015 | ||
40016 | ||
40017 | <RESULT> | |
40018 | ||
40019 | Overall verdict: pass | |
40020 | ||
40021 | <END_TC> | |
40022 | ||
40023 | :exmp. | |
40024 | ||
40025 | .*---------------------------------------------------------------------* | |
40026 | :h3. DECODING ,reverse order, SET with CHOICE element, AUTOMATIC TAGS | |
40027 | .*---------------------------------------------------------------------* | |
40028 | :xmp tab=0. | |
40029 | ||
40030 | <TC - DECODING ,reverse order, SET with CHOICE element, AUTOMATIC TAGS> | |
40031 | ||
40032 | <STATIC:ASN> | |
40033 | ||
40034 | TempA | |
40035 | ||
40036 | DEFINITIONS | |
40037 | ||
40038 | AUTOMATIC TAGS | |
40039 | ||
40040 | ||
40041 | ::= | |
40042 | ||
40043 | BEGIN | |
40044 | ||
40045 | BERPDU ::= SET | |
40046 | { | |
40047 | b CHOICE { | |
40048 | x BOOLEAN, | |
40049 | y OCTET STRING | |
40050 | } | |
40051 | OPTIONAL, | |
40052 | ||
40053 | ||
40054 | c INTEGER OPTIONAL | |
40055 | ||
40056 | } | |
40057 | ||
40058 | ||
40059 | END | |
40060 | ||
40061 | <STATIC> | |
40062 | ||
40063 | import from TempA all; | |
40064 | ||
40065 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40066 | ||
40067 | ||
40068 | const BERPDU myValue := {b := {x := true}, | |
40069 | c := 4 | |
40070 | } | |
40071 | ||
40072 | ||
40073 | <TTCN_TC:EXEC> | |
40074 | ||
40075 | if (dec_BER_PDU('3180810104A0808001FF00000000'O) == myValue) | |
40076 | ||
40077 | ||
40078 | ||
40079 | {setverdict(pass);} else {setverdict(fail);} | |
40080 | ||
40081 | ||
40082 | <RESULT> | |
40083 | ||
40084 | Overall verdict: pass | |
40085 | ||
40086 | <END_TC> | |
40087 | ||
40088 | :exmp. | |
40089 | ||
40090 | .*---------------------------------------------------------------------* | |
40091 | :h3. DECODING ,DER, SET with CHOICE element, | |
40092 | .*---------------------------------------------------------------------* | |
40093 | :xmp tab=0. | |
40094 | ||
40095 | <TC - DECODING ,DER, SET with CHOICE element, > | |
40096 | ||
40097 | <STATIC:ASN> | |
40098 | ||
40099 | TempA | |
40100 | ||
40101 | DEFINITIONS | |
40102 | ||
40103 | ||
40104 | ||
40105 | ::= | |
40106 | ||
40107 | BEGIN | |
40108 | ||
40109 | ||
40110 | BERPDU ::= SET | |
40111 | { | |
40112 | b CHOICE { | |
40113 | x BOOLEAN, | |
40114 | y OCTET STRING | |
40115 | } | |
40116 | OPTIONAL, | |
40117 | ||
40118 | ||
40119 | c INTEGER OPTIONAL | |
40120 | ||
40121 | } | |
40122 | ||
40123 | ||
40124 | END | |
40125 | ||
40126 | <STATIC> | |
40127 | ||
40128 | import from TempA all; | |
40129 | ||
40130 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40131 | ||
40132 | const BERPDU myValue := {b := {x := true}, | |
40133 | c := 4 | |
40134 | } | |
40135 | ||
40136 | ||
40137 | ||
40138 | <TTCN_TC:EXEC> | |
40139 | ||
40140 | if (dec_BER_PDU('31060101FF020104'O) == myValue) {setverdict(pass);} else {setverdict(fail);} | |
40141 | ||
40142 | ||
40143 | <RESULT> | |
40144 | ||
40145 | Overall verdict: pass | |
40146 | ||
40147 | <END_TC> | |
40148 | ||
40149 | :exmp. | |
40150 | ||
40151 | .*---------------------------------------------------------------------* | |
40152 | :h3. DECODING ,CER, SET with CHOICE element, | |
40153 | .*---------------------------------------------------------------------* | |
40154 | :xmp tab=0. | |
40155 | ||
40156 | <TC - DECODING ,CER, SET with CHOICE element, > | |
40157 | ||
40158 | <STATIC:ASN> | |
40159 | ||
40160 | TempA | |
40161 | ||
40162 | DEFINITIONS | |
40163 | ||
40164 | ||
40165 | ||
40166 | ::= | |
40167 | ||
40168 | BEGIN | |
40169 | ||
40170 | ||
40171 | BERPDU ::= SET | |
40172 | { | |
40173 | b CHOICE { | |
40174 | x BOOLEAN, | |
40175 | y OCTET STRING | |
40176 | } | |
40177 | OPTIONAL, | |
40178 | ||
40179 | ||
40180 | c INTEGER OPTIONAL | |
40181 | ||
40182 | } | |
40183 | ||
40184 | END | |
40185 | ||
40186 | <STATIC> | |
40187 | ||
40188 | import from TempA all; | |
40189 | ||
40190 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40191 | ||
40192 | ||
40193 | const BERPDU myValue := {b := {x := true}, | |
40194 | c := 4 | |
40195 | } | |
40196 | ||
40197 | ||
40198 | <TTCN_TC:EXEC> | |
40199 | ||
40200 | if (dec_BER_PDU('31800101FF0201040000'O) == myValue){setverdict(pass);} else {setverdict(fail);} | |
40201 | ||
40202 | ||
40203 | <RESULT> | |
40204 | ||
40205 | Overall verdict: pass | |
40206 | ||
40207 | <END_TC> | |
40208 | ||
40209 | :exmp. | |
40210 | ||
40211 | .*---------------------------------------------------------------------* | |
40212 | :h3. DECODING ,reverse order, SET with CHOICE element, | |
40213 | .*---------------------------------------------------------------------* | |
40214 | :xmp tab=0. | |
40215 | ||
40216 | <TC - DECODING ,reverse order, SET with CHOICE element, > | |
40217 | ||
40218 | <STATIC:ASN> | |
40219 | ||
40220 | TempA | |
40221 | ||
40222 | DEFINITIONS | |
40223 | ||
40224 | ||
40225 | ||
40226 | ::= | |
40227 | ||
40228 | BEGIN | |
40229 | ||
40230 | ||
40231 | BERPDU ::= SET | |
40232 | { | |
40233 | b CHOICE { | |
40234 | x BOOLEAN, | |
40235 | y OCTET STRING | |
40236 | } | |
40237 | OPTIONAL, | |
40238 | ||
40239 | ||
40240 | c INTEGER OPTIONAL | |
40241 | ||
40242 | } | |
40243 | ||
40244 | ||
40245 | END | |
40246 | ||
40247 | <STATIC> | |
40248 | ||
40249 | import from TempA all; | |
40250 | ||
40251 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40252 | ||
40253 | const BERPDU myValue := {b := {x := true}, | |
40254 | c := 4 | |
40255 | } | |
40256 | ||
40257 | ||
40258 | ||
40259 | <TTCN_TC:EXEC> | |
40260 | ||
40261 | if (dec_BER_PDU('31060201040101FF'O) == myValue) | |
40262 | ||
40263 | ||
40264 | ||
40265 | {setverdict(pass);} else {setverdict(fail);} | |
40266 | ||
40267 | ||
40268 | <RESULT> | |
40269 | ||
40270 | Overall verdict: pass | |
40271 | ||
40272 | <END_TC> | |
40273 | ||
40274 | :exmp. | |
40275 | ||
40276 | .*---------------------------------------------------------------------* | |
40277 | :h3. DECODING ,reverse order, SET with CHOICE element, | |
40278 | .*---------------------------------------------------------------------* | |
40279 | :xmp tab=0. | |
40280 | ||
40281 | <TC - DECODING ,reverse order, SET with CHOICE element, > | |
40282 | ||
40283 | <STATIC:ASN> | |
40284 | ||
40285 | TempA | |
40286 | ||
40287 | DEFINITIONS | |
40288 | ||
40289 | ||
40290 | ||
40291 | ::= | |
40292 | ||
40293 | BEGIN | |
40294 | ||
40295 | ||
40296 | BERPDU ::= SET | |
40297 | { | |
40298 | b CHOICE { | |
40299 | x BOOLEAN, | |
40300 | y OCTET STRING | |
40301 | } | |
40302 | OPTIONAL, | |
40303 | ||
40304 | ||
40305 | c INTEGER OPTIONAL | |
40306 | ||
40307 | } | |
40308 | ||
40309 | END | |
40310 | ||
40311 | <STATIC> | |
40312 | ||
40313 | import from TempA all; | |
40314 | ||
40315 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40316 | ||
40317 | ||
40318 | const BERPDU myValue := {b := {x := true}, | |
40319 | c := 4 | |
40320 | } | |
40321 | ||
40322 | ||
40323 | <TTCN_TC:EXEC> | |
40324 | ||
40325 | if (dec_BER_PDU('31800201040101FF0000'O) == myValue) | |
40326 | ||
40327 | ||
40328 | ||
40329 | {setverdict(pass);} else {setverdict(fail);} | |
40330 | ||
40331 | ||
40332 | <RESULT> | |
40333 | ||
40334 | Overall verdict: pass | |
40335 | ||
40336 | <END_TC> | |
40337 | ||
40338 | :exmp. | |
40339 | ||
40340 | .*---------------------------------------------------------------------* | |
40341 | :h3. DECODING DER, SET with CHOICE element, different choice | |
40342 | .*---------------------------------------------------------------------* | |
40343 | :xmp tab=0. | |
40344 | ||
40345 | <TC - DECODING DER, SET with CHOICE element, different choice > | |
40346 | ||
40347 | <STATIC:ASN> | |
40348 | ||
40349 | TempA | |
40350 | ||
40351 | DEFINITIONS | |
40352 | ||
40353 | ||
40354 | ||
40355 | ::= | |
40356 | ||
40357 | BEGIN | |
40358 | ||
40359 | ||
40360 | BERPDU ::= SET | |
40361 | { | |
40362 | b CHOICE { | |
40363 | x BOOLEAN, | |
40364 | y OCTET STRING | |
40365 | } | |
40366 | OPTIONAL, | |
40367 | ||
40368 | ||
40369 | c INTEGER OPTIONAL | |
40370 | ||
40371 | } | |
40372 | ||
40373 | END | |
40374 | ||
40375 | <STATIC> | |
40376 | ||
40377 | import from TempA all; | |
40378 | ||
40379 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40380 | ||
40381 | ||
40382 | const BERPDU myValue := {b := {y := 'FF'O}, | |
40383 | c := 4 | |
40384 | } | |
40385 | ||
40386 | ||
40387 | <TTCN_TC:EXEC> | |
40388 | ||
40389 | if (dec_BER_PDU('31060201040401FF'O) == myValue) | |
40390 | ||
40391 | ||
40392 | ||
40393 | {setverdict(pass);} else {setverdict(fail);} | |
40394 | ||
40395 | ||
40396 | <RESULT> | |
40397 | ||
40398 | Overall verdict: pass | |
40399 | ||
40400 | <END_TC> | |
40401 | ||
40402 | :exmp. | |
40403 | ||
40404 | .*---------------------------------------------------------------------* | |
40405 | :h3. DECODING CER, SET with CHOICE element, different choice | |
40406 | .*---------------------------------------------------------------------* | |
40407 | :xmp tab=0. | |
40408 | ||
40409 | <TC - DECODING CER, SET with CHOICE element, different choice > | |
40410 | ||
40411 | <STATIC:ASN> | |
40412 | ||
40413 | TempA | |
40414 | ||
40415 | DEFINITIONS | |
40416 | ||
40417 | ||
40418 | ||
40419 | ::= | |
40420 | ||
40421 | BEGIN | |
40422 | ||
40423 | ||
40424 | BERPDU ::= SET | |
40425 | { | |
40426 | b CHOICE { | |
40427 | x BOOLEAN, | |
40428 | y OCTET STRING | |
40429 | } | |
40430 | OPTIONAL, | |
40431 | ||
40432 | ||
40433 | c INTEGER OPTIONAL | |
40434 | ||
40435 | } | |
40436 | ||
40437 | END | |
40438 | ||
40439 | <STATIC> | |
40440 | ||
40441 | import from TempA all; | |
40442 | ||
40443 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40444 | ||
40445 | ||
40446 | const BERPDU myValue := {b := {y := 'FF'O}, | |
40447 | c := 4 | |
40448 | } | |
40449 | ||
40450 | ||
40451 | <TTCN_TC:EXEC> | |
40452 | ||
40453 | if (dec_BER_PDU('31800401FF0201040000'O) == myValue) | |
40454 | ||
40455 | ||
40456 | ||
40457 | {setverdict(pass);} else {setverdict(fail);} | |
40458 | ||
40459 | ||
40460 | <RESULT> | |
40461 | ||
40462 | Overall verdict: pass | |
40463 | ||
40464 | <END_TC> | |
40465 | ||
40466 | :exmp. | |
40467 | ||
40468 | .*---------------------------------------------------------------------* | |
40469 | :h3. DECODING , SET with CHOICE element, different choice | |
40470 | .*---------------------------------------------------------------------* | |
40471 | :xmp tab=0. | |
40472 | ||
40473 | <TC - DECODING , SET with CHOICE element, different choice > | |
40474 | ||
40475 | <STATIC:ASN> | |
40476 | ||
40477 | TempA | |
40478 | ||
40479 | DEFINITIONS | |
40480 | ||
40481 | ||
40482 | ||
40483 | ::= | |
40484 | ||
40485 | BEGIN | |
40486 | ||
40487 | ||
40488 | BERPDU ::= SET | |
40489 | { | |
40490 | b CHOICE { | |
40491 | x BOOLEAN, | |
40492 | y OCTET STRING | |
40493 | } | |
40494 | OPTIONAL, | |
40495 | ||
40496 | ||
40497 | c INTEGER OPTIONAL | |
40498 | ||
40499 | } | |
40500 | ||
40501 | END | |
40502 | ||
40503 | <STATIC> | |
40504 | ||
40505 | import from TempA all; | |
40506 | ||
40507 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40508 | ||
40509 | ||
40510 | const BERPDU myValue := {b := {y := 'FF'O}, | |
40511 | c := 4 | |
40512 | } | |
40513 | ||
40514 | ||
40515 | <TTCN_TC:EXEC> | |
40516 | ||
40517 | if (dec_BER_PDU('31060401FF020104'O) == myValue) | |
40518 | ||
40519 | ||
40520 | ||
40521 | {setverdict(pass);} else {setverdict(fail);} | |
40522 | ||
40523 | ||
40524 | <RESULT> | |
40525 | ||
40526 | Overall verdict: pass | |
40527 | ||
40528 | <END_TC> | |
40529 | ||
40530 | :exmp. | |
40531 | ||
40532 | .*---------------------------------------------------------------------* | |
40533 | :h3. DECODING , SET with CHOICE element, different choice | |
40534 | .*---------------------------------------------------------------------* | |
40535 | :xmp tab=0. | |
40536 | ||
40537 | <TC - DECODING , SET with CHOICE element, different choice > | |
40538 | ||
40539 | <STATIC:ASN> | |
40540 | ||
40541 | TempA | |
40542 | ||
40543 | DEFINITIONS | |
40544 | ||
40545 | ||
40546 | ||
40547 | ::= | |
40548 | ||
40549 | BEGIN | |
40550 | ||
40551 | ||
40552 | BERPDU ::= SET | |
40553 | { | |
40554 | b CHOICE { | |
40555 | x BOOLEAN, | |
40556 | y OCTET STRING | |
40557 | } | |
40558 | OPTIONAL, | |
40559 | ||
40560 | ||
40561 | c INTEGER OPTIONAL | |
40562 | ||
40563 | } | |
40564 | ||
40565 | END | |
40566 | ||
40567 | <STATIC> | |
40568 | ||
40569 | import from TempA all; | |
40570 | ||
40571 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40572 | ||
40573 | ||
40574 | const BERPDU myValue := {b := {y := 'FF'O}, | |
40575 | c := 4 | |
40576 | } | |
40577 | ||
40578 | ||
40579 | <TTCN_TC:EXEC> | |
40580 | ||
40581 | if (dec_BER_PDU('31800201040401FF0000'O) == myValue) | |
40582 | ||
40583 | ||
40584 | ||
40585 | {setverdict(pass);} else {setverdict(fail);} | |
40586 | ||
40587 | ||
40588 | <RESULT> | |
40589 | ||
40590 | Overall verdict: pass | |
40591 | ||
40592 | <END_TC> | |
40593 | ||
40594 | :exmp. | |
40595 | ||
40596 | .*---------------------------------------------------------------------* | |
40597 | :h3. DECODING ,DER, SET with EXTENSION , AUTOMATIC TAGS | |
40598 | .*---------------------------------------------------------------------* | |
40599 | :xmp tab=0. | |
40600 | ||
40601 | <TC - DECODING ,DER, SET with EXTENSION , AUTOMATIC TAGS> | |
40602 | ||
40603 | <STATIC:ASN> | |
40604 | ||
40605 | TempA | |
40606 | ||
40607 | DEFINITIONS | |
40608 | ||
40609 | AUTOMATIC TAGS | |
40610 | ||
40611 | ::= | |
40612 | ||
40613 | BEGIN | |
40614 | ||
40615 | ||
40616 | ||
40617 | BERPDU ::= SET | |
40618 | { | |
40619 | ||
40620 | a OCTET STRING, | |
40621 | ||
40622 | b BOOLEAN, | |
40623 | ||
40624 | c INTEGER OPTIONAL, | |
40625 | ||
40626 | ..., | |
40627 | ||
40628 | d BIT STRING | |
40629 | ||
40630 | ||
40631 | ||
40632 | ||
40633 | } | |
40634 | ||
40635 | END | |
40636 | ||
40637 | <STATIC> | |
40638 | ||
40639 | import from TempA all; | |
40640 | ||
40641 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40642 | ||
40643 | ||
40644 | const BERPDU myValue := { | |
40645 | a := 'FF'O, | |
40646 | b := true, | |
40647 | d := '1'B, | |
40648 | c := 4 | |
40649 | } | |
40650 | ||
40651 | <TTCN_TC:EXEC> | |
40652 | ||
40653 | if (dec_BER_PDU('310D8001FF8101FF82010483020780'O) == myValue) | |
40654 | ||
40655 | ||
40656 | ||
40657 | {setverdict(pass);} else {setverdict(fail);} | |
40658 | ||
40659 | ||
40660 | <RESULT> | |
40661 | ||
40662 | Overall verdict: pass | |
40663 | ||
40664 | <END_TC> | |
40665 | ||
40666 | :exmp. | |
40667 | ||
40668 | .*---------------------------------------------------------------------* | |
40669 | :h3. DECODING ,CER, SET with EXTENSION , AUTOMATIC TAGS | |
40670 | .*---------------------------------------------------------------------* | |
40671 | :xmp tab=0. | |
40672 | ||
40673 | <TC - DECODING ,CER, SET with EXTENSION , AUTOMATIC TAGS> | |
40674 | ||
40675 | <STATIC:ASN> | |
40676 | ||
40677 | TempA | |
40678 | ||
40679 | DEFINITIONS | |
40680 | ||
40681 | AUTOMATIC TAGS | |
40682 | ||
40683 | ::= | |
40684 | ||
40685 | BEGIN | |
40686 | ||
40687 | ||
40688 | ||
40689 | BERPDU ::= SET | |
40690 | { | |
40691 | ||
40692 | a OCTET STRING, | |
40693 | ||
40694 | b BOOLEAN, | |
40695 | ||
40696 | c INTEGER OPTIONAL, | |
40697 | ||
40698 | ..., | |
40699 | ||
40700 | d BIT STRING | |
40701 | ||
40702 | ||
40703 | } | |
40704 | ||
40705 | END | |
40706 | ||
40707 | <STATIC> | |
40708 | ||
40709 | import from TempA all; | |
40710 | ||
40711 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40712 | ||
40713 | ||
40714 | const BERPDU myValue := { | |
40715 | a := 'FF'O, | |
40716 | b := true, | |
40717 | d := '1'B, | |
40718 | c := 4 | |
40719 | } | |
40720 | ||
40721 | <TTCN_TC:EXEC> | |
40722 | ||
40723 | if (dec_BER_PDU('31808001FF8101FF820104830207800000'O) == myValue) | |
40724 | ||
40725 | ||
40726 | ||
40727 | {setverdict(pass);} else {setverdict(fail);} | |
40728 | ||
40729 | ||
40730 | <RESULT> | |
40731 | ||
40732 | Overall verdict: pass | |
40733 | ||
40734 | <END_TC> | |
40735 | ||
40736 | :exmp. | |
40737 | ||
40738 | .*---------------------------------------------------------------------* | |
40739 | :h3. DECODING ,different order, SET with EXTENSION , AUTOMATIC TAGS | |
40740 | .*---------------------------------------------------------------------* | |
40741 | :xmp tab=0. | |
40742 | ||
40743 | <TC - DECODING ,different order, SET with EXTENSION , AUTOMATIC TAGS> | |
40744 | ||
40745 | <STATIC:ASN> | |
40746 | ||
40747 | TempA | |
40748 | ||
40749 | DEFINITIONS | |
40750 | ||
40751 | AUTOMATIC TAGS | |
40752 | ||
40753 | ::= | |
40754 | ||
40755 | BEGIN | |
40756 | ||
40757 | ||
40758 | ||
40759 | BERPDU ::= SET | |
40760 | { | |
40761 | ||
40762 | a OCTET STRING, | |
40763 | ||
40764 | b BOOLEAN, | |
40765 | ||
40766 | c INTEGER OPTIONAL, | |
40767 | ||
40768 | ..., | |
40769 | ||
40770 | d BIT STRING | |
40771 | ||
40772 | ||
40773 | ||
40774 | ||
40775 | } | |
40776 | ||
40777 | END | |
40778 | ||
40779 | <STATIC> | |
40780 | ||
40781 | import from TempA all; | |
40782 | ||
40783 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40784 | ||
40785 | ||
40786 | const BERPDU myValue := { | |
40787 | a := 'FF'O, | |
40788 | b := true, | |
40789 | d := '1'B, | |
40790 | c := 4 | |
40791 | } | |
40792 | ||
40793 | <TTCN_TC:EXEC> | |
40794 | ||
40795 | if (dec_BER_PDU('310D8001FF830207808101FF820104'O) == myValue) | |
40796 | ||
40797 | ||
40798 | ||
40799 | {setverdict(pass);} else {setverdict(fail);} | |
40800 | ||
40801 | ||
40802 | <RESULT> | |
40803 | ||
40804 | Overall verdict: pass | |
40805 | ||
40806 | <END_TC> | |
40807 | ||
40808 | :exmp. | |
40809 | ||
40810 | .*---------------------------------------------------------------------* | |
40811 | :h3. DECODING ,different order, SET with EXTENSION , AUTOMATIC TAGS | |
40812 | .*---------------------------------------------------------------------* | |
40813 | :xmp tab=0. | |
40814 | ||
40815 | <TC - DECODING ,different order, SET with EXTENSION , AUTOMATIC TAGS> | |
40816 | ||
40817 | <STATIC:ASN> | |
40818 | ||
40819 | TempA | |
40820 | ||
40821 | DEFINITIONS | |
40822 | ||
40823 | AUTOMATIC TAGS | |
40824 | ||
40825 | ::= | |
40826 | ||
40827 | BEGIN | |
40828 | ||
40829 | ||
40830 | ||
40831 | BERPDU ::= SET | |
40832 | { | |
40833 | ||
40834 | a OCTET STRING, | |
40835 | ||
40836 | b BOOLEAN, | |
40837 | ||
40838 | c INTEGER OPTIONAL, | |
40839 | ||
40840 | ..., | |
40841 | ||
40842 | d BIT STRING | |
40843 | ||
40844 | ||
40845 | } | |
40846 | ||
40847 | END | |
40848 | ||
40849 | <STATIC> | |
40850 | ||
40851 | import from TempA all; | |
40852 | ||
40853 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40854 | ||
40855 | ||
40856 | const BERPDU myValue := { | |
40857 | a := 'FF'O, | |
40858 | b := true, | |
40859 | d := '1'B, | |
40860 | c := 4 | |
40861 | } | |
40862 | ||
40863 | <TTCN_TC:EXEC> | |
40864 | ||
40865 | if (dec_BER_PDU('31808001FF830207808101FF8201040000'O) == myValue) | |
40866 | ||
40867 | ||
40868 | ||
40869 | {setverdict(pass);} else {setverdict(fail);} | |
40870 | ||
40871 | ||
40872 | <RESULT> | |
40873 | ||
40874 | Overall verdict: pass | |
40875 | ||
40876 | <END_TC> | |
40877 | ||
40878 | :exmp. | |
40879 | ||
40880 | .*---------------------------------------------------------------------* | |
40881 | :h3. DECODING SET with Long Form , AUTOMATIC TAGS | |
40882 | .*---------------------------------------------------------------------* | |
40883 | :xmp tab=0. | |
40884 | ||
40885 | <TC - DECODING SET with Long Form , AUTOMATIC TAGS> | |
40886 | ||
40887 | <STATIC:ASN> | |
40888 | ||
40889 | TempA | |
40890 | ||
40891 | DEFINITIONS | |
40892 | ||
40893 | AUTOMATIC TAGS | |
40894 | ||
40895 | ::= | |
40896 | ||
40897 | BEGIN | |
40898 | ||
40899 | ||
40900 | ||
40901 | BERPDU ::= SET | |
40902 | { | |
40903 | ||
40904 | a OCTET STRING, | |
40905 | ||
40906 | b BOOLEAN, | |
40907 | ||
40908 | c INTEGER OPTIONAL, | |
40909 | ||
40910 | ..., | |
40911 | ||
40912 | d BIT STRING | |
40913 | ||
40914 | ||
40915 | ||
40916 | ||
40917 | } | |
40918 | ||
40919 | END | |
40920 | ||
40921 | <STATIC> | |
40922 | ||
40923 | import from TempA all; | |
40924 | ||
40925 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40926 | ||
40927 | ||
40928 | const BERPDU myValue := { | |
40929 | a := 'FF'O, | |
40930 | b := true, | |
40931 | d := '1'B, | |
40932 | c := 4 | |
40933 | } | |
40934 | ||
40935 | <TTCN_TC:EXEC> | |
40936 | ||
40937 | if (dec_BER_PDU('318300000D8001FF8101FF82010483020780'O) == myValue) | |
40938 | ||
40939 | ||
40940 | ||
40941 | {setverdict(pass);} else {setverdict(fail);} | |
40942 | ||
40943 | ||
40944 | <RESULT> | |
40945 | ||
40946 | Overall verdict: pass | |
40947 | ||
40948 | <END_TC> | |
40949 | ||
40950 | :exmp. | |
40951 | ||
40952 | .*---------------------------------------------------------------------* | |
40953 | :h3. DECODING, different order, SET with Long Form , AUTOMATIC TAGS | |
40954 | .*---------------------------------------------------------------------* | |
40955 | :xmp tab=0. | |
40956 | ||
40957 | <TC - DECODING, different order, SET with Long Form , AUTOMATIC TAGS> | |
40958 | ||
40959 | <STATIC:ASN> | |
40960 | ||
40961 | TempA | |
40962 | ||
40963 | DEFINITIONS | |
40964 | ||
40965 | AUTOMATIC TAGS | |
40966 | ||
40967 | ::= | |
40968 | ||
40969 | BEGIN | |
40970 | ||
40971 | ||
40972 | ||
40973 | BERPDU ::= SET | |
40974 | { | |
40975 | ||
40976 | a OCTET STRING, | |
40977 | ||
40978 | b BOOLEAN, | |
40979 | ||
40980 | c INTEGER OPTIONAL, | |
40981 | ||
40982 | ..., | |
40983 | ||
40984 | d BIT STRING | |
40985 | ||
40986 | ||
40987 | ||
40988 | ||
40989 | } | |
40990 | ||
40991 | END | |
40992 | ||
40993 | <STATIC> | |
40994 | ||
40995 | import from TempA all; | |
40996 | ||
40997 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
40998 | ||
40999 | ||
41000 | const BERPDU myValue := { | |
41001 | a := 'FF'O, | |
41002 | b := true, | |
41003 | d := '1'B, | |
41004 | c := 4 | |
41005 | } | |
41006 | ||
41007 | <TTCN_TC:EXEC> | |
41008 | ||
41009 | if (dec_BER_PDU('318300000D8101FF820104830207808001FF'O) == myValue) | |
41010 | ||
41011 | ||
41012 | ||
41013 | {setverdict(pass);} else {setverdict(fail);} | |
41014 | ||
41015 | ||
41016 | <RESULT> | |
41017 | ||
41018 | Overall verdict: pass | |
41019 | ||
41020 | <END_TC> | |
41021 | ||
41022 | :exmp. | |
41023 | ||
41024 | .*---------------------------------------------------------------------* | |
41025 | :h3. DECODING , DER, SET with fields of different types , | |
41026 | .*---------------------------------------------------------------------* | |
41027 | :xmp tab=0. | |
41028 | ||
41029 | <TC - DECODING , DER, SET with fields of different types ,> | |
41030 | ||
41031 | <STATIC:ASN> | |
41032 | ||
41033 | TempA | |
41034 | ||
41035 | DEFINITIONS | |
41036 | ||
41037 | ||
41038 | ::= | |
41039 | ||
41040 | BEGIN | |
41041 | ||
41042 | ||
41043 | BERPDU ::= SET | |
41044 | { | |
41045 | a NULL, | |
41046 | b BOOLEAN, | |
41047 | c INTEGER, | |
41048 | d ENUMERATED {first ,second ,third}, | |
41049 | --e REAL, | |
41050 | f BIT STRING, | |
41051 | g OCTET STRING, | |
41052 | ||
41053 | h OBJECT IDENTIFIER, | |
41054 | i IA5String, | |
41055 | j CHOICE {x1 [1] BOOLEAN, | |
41056 | y1 [2] OCTET STRING}, | |
41057 | ||
41058 | k SEQUENCE{x2 NULL, | |
41059 | y2 BOOLEAN}, | |
41060 | ||
41061 | l SET { x3 BIT STRING, | |
41062 | y3 NULL}, | |
41063 | ||
41064 | m [3] SEQUENCE OF INTEGER, | |
41065 | n [4] SET OF BOOLEAN | |
41066 | } | |
41067 | ||
41068 | ||
41069 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
41070 | ||
41071 | ||
41072 | END | |
41073 | ||
41074 | <STATIC> | |
41075 | ||
41076 | import from TempA all; | |
41077 | ||
41078 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
41079 | ||
41080 | ||
41081 | const BERPDU myValue := {a := NULL, | |
41082 | b := true, | |
41083 | c := 2, | |
41084 | d := first, | |
41085 | // e := 1.0, | |
41086 | f := '1'B, | |
41087 | g := 'FFFF'O, | |
41088 | h := myOBJID, | |
41089 | i := "ABC", | |
41090 | j := {x1 := true } , | |
41091 | k := {x2 := NULL, | |
41092 | ||
41093 | y2 := true } , | |
41094 | l := {y3 := NULL , | |
41095 | ||
41096 | x3 := '1'B } , | |
41097 | m := | |
41098 | { 1 ,2 } , | |
41099 | n := | |
41100 | { true, true } | |
41101 | } | |
41102 | ||
41103 | ||
41104 | ||
41105 | ||
41106 | ||
41107 | <TTCN_TC:EXEC> | |
41108 | ||
41109 | if (dec_BER_PDU('31450101FF020102030207800402FFFF050006030002030A01001603414243300505000101FF3106030207800500A1030101FFA3083006020101020102A40831060101FF0101FF'O) == myValue) | |
41110 | ||
41111 | ||
41112 | ||
41113 | {setverdict(pass);} else {setverdict(fail);} | |
41114 | ||
41115 | ||
41116 | <RESULT> | |
41117 | ||
41118 | Overall verdict: pass | |
41119 | ||
41120 | <END_TC> | |
41121 | ||
41122 | :exmp. | |
41123 | ||
41124 | .*---------------------------------------------------------------------* | |
41125 | :h3. DECODING , CER, SET with fields of different types , | |
41126 | .*---------------------------------------------------------------------* | |
41127 | :xmp tab=0. | |
41128 | ||
41129 | <TC - DECODING , CER, SET with fields of different types ,> | |
41130 | ||
41131 | <STATIC:ASN> | |
41132 | ||
41133 | TempA | |
41134 | ||
41135 | DEFINITIONS | |
41136 | ||
41137 | ||
41138 | ::= | |
41139 | ||
41140 | BEGIN | |
41141 | ||
41142 | ||
41143 | BERPDU ::= SET | |
41144 | { | |
41145 | a NULL, | |
41146 | b BOOLEAN, | |
41147 | c INTEGER, | |
41148 | d ENUMERATED {first ,second ,third}, | |
41149 | -- e REAL, | |
41150 | f BIT STRING, | |
41151 | g OCTET STRING, | |
41152 | ||
41153 | h OBJECT IDENTIFIER, | |
41154 | i IA5String, | |
41155 | j CHOICE {x1 [1] BOOLEAN, | |
41156 | y1 [2] OCTET STRING}, | |
41157 | ||
41158 | k SEQUENCE{x2 NULL, | |
41159 | y2 BOOLEAN}, | |
41160 | ||
41161 | l SET { x3 BIT STRING, | |
41162 | y3 NULL}, | |
41163 | ||
41164 | m [3] SEQUENCE OF INTEGER, | |
41165 | n [4] SET OF BOOLEAN | |
41166 | } | |
41167 | ||
41168 | ||
41169 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
41170 | ||
41171 | ||
41172 | END | |
41173 | ||
41174 | <STATIC> | |
41175 | ||
41176 | import from TempA all; | |
41177 | ||
41178 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
41179 | ||
41180 | ||
41181 | const BERPDU myValue := {a := NULL, | |
41182 | b := true, | |
41183 | c := 2, | |
41184 | d := first, | |
41185 | // e := 1.0, 090603312E452B30 | |
41186 | f := '1'B, | |
41187 | g := 'FFFF'O, | |
41188 | h := myOBJID, | |
41189 | i := "ABC", | |
41190 | j := {x1 := true } , | |
41191 | k := {x2 := NULL, | |
41192 | ||
41193 | y2 := true } , | |
41194 | l := {y3 := NULL , | |
41195 | ||
41196 | x3 := '1'B } , | |
41197 | m := | |
41198 | { 1 ,2 } , | |
41199 | n := | |
41200 | { true, true } | |
41201 | } | |
41202 | ||
41203 | ||
41204 | ||
41205 | ||
41206 | ||
41207 | <TTCN_TC:EXEC> | |
41208 | ||
41209 | if (dec_BER_PDU('31800101FF020102030207800402FFFF050006030002030A01001603414243308005000101FF000031800302078005000000A1800101FF0000A380308002010102010200000000A48031800101FF0101FF000000000000'O) == myValue) | |
41210 | ||
41211 | ||
41212 | ||
41213 | {setverdict(pass);} else {setverdict(fail);} | |
41214 | ||
41215 | ||
41216 | <RESULT> | |
41217 | ||
41218 | Overall verdict: pass | |
41219 | ||
41220 | <END_TC> | |
41221 | ||
41222 | :exmp. | |
41223 | ||
41224 | .*---------------------------------------------------------------------* | |
41225 | :h3. DECODING , different order, SET with fields of different types , different order | |
41226 | .*---------------------------------------------------------------------* | |
41227 | :xmp tab=0. | |
41228 | ||
41229 | <TC - DECODING , different order, SET with fields of different types , different order > | |
41230 | ||
41231 | <STATIC:ASN> | |
41232 | ||
41233 | TempA | |
41234 | ||
41235 | DEFINITIONS | |
41236 | ||
41237 | ||
41238 | ::= | |
41239 | ||
41240 | BEGIN | |
41241 | ||
41242 | ||
41243 | BERPDU ::= SET | |
41244 | { | |
41245 | a NULL, | |
41246 | b BOOLEAN, | |
41247 | c INTEGER, | |
41248 | d ENUMERATED {first ,second ,third}, | |
41249 | --e REAL, | |
41250 | f BIT STRING, | |
41251 | g OCTET STRING, | |
41252 | ||
41253 | h OBJECT IDENTIFIER, | |
41254 | i IA5String, | |
41255 | j CHOICE {x1 [1] BOOLEAN, | |
41256 | y1 [2] OCTET STRING}, | |
41257 | ||
41258 | k SEQUENCE{x2 NULL, | |
41259 | y2 BOOLEAN}, | |
41260 | ||
41261 | l SET { x3 BIT STRING, | |
41262 | y3 NULL}, | |
41263 | ||
41264 | m [3] SEQUENCE OF INTEGER, | |
41265 | n [4] SET OF BOOLEAN | |
41266 | } | |
41267 | ||
41268 | ||
41269 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
41270 | ||
41271 | ||
41272 | END | |
41273 | ||
41274 | <STATIC> | |
41275 | ||
41276 | import from TempA all; | |
41277 | ||
41278 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
41279 | ||
41280 | ||
41281 | const BERPDU myValue := {a := NULL, | |
41282 | b := true, | |
41283 | c := 2, | |
41284 | d := first, | |
41285 | // e := 1.0, | |
41286 | f := '1'B, | |
41287 | g := 'FFFF'O, | |
41288 | h := myOBJID, | |
41289 | i := "ABC", | |
41290 | j := {x1 := true } , | |
41291 | k := {x2 := NULL, | |
41292 | ||
41293 | y2 := true } , | |
41294 | l := {y3 := NULL , | |
41295 | ||
41296 | x3 := '1'B } , | |
41297 | m := | |
41298 | { 1 ,2 } , | |
41299 | n := | |
41300 | { true, true } | |
41301 | } | |
41302 | ||
41303 | ||
41304 | ||
41305 | ||
41306 | ||
41307 | <TTCN_TC:EXEC> | |
41308 | ||
41309 | if (dec_BER_PDU('31450101FF0201020A0100030207800402FFFF06030002031603414243A1030101FF300505000101FF3106030207800500A3083006020101020102A40831060101FF0101FF0500'O) == myValue) | |
41310 | ||
41311 | ||
41312 | ||
41313 | {setverdict(pass);} else {setverdict(fail);} | |
41314 | ||
41315 | ||
41316 | <RESULT> | |
41317 | ||
41318 | Overall verdict: pass | |
41319 | ||
41320 | <END_TC> | |
41321 | ||
41322 | :exmp. | |
41323 | ||
41324 | .*---------------------------------------------------------------------* | |
41325 | :h3. DECODING , different order, SET with fields of different types , different order2 | |
41326 | .*---------------------------------------------------------------------* | |
41327 | :xmp tab=0. | |
41328 | ||
41329 | <TC - DECODING , different order, SET with fields of different types , different order2> | |
41330 | ||
41331 | <STATIC:ASN> | |
41332 | ||
41333 | TempA | |
41334 | ||
41335 | DEFINITIONS | |
41336 | ||
41337 | ||
41338 | ::= | |
41339 | ||
41340 | BEGIN | |
41341 | ||
41342 | ||
41343 | BERPDU ::= SET | |
41344 | { | |
41345 | a NULL, | |
41346 | b BOOLEAN, | |
41347 | c INTEGER, | |
41348 | d ENUMERATED {first ,second ,third}, | |
41349 | -- e REAL, | |
41350 | f BIT STRING, | |
41351 | g OCTET STRING, | |
41352 | ||
41353 | h OBJECT IDENTIFIER, | |
41354 | i IA5String, | |
41355 | j CHOICE {x1 [1] BOOLEAN, | |
41356 | y1 [2] OCTET STRING}, | |
41357 | ||
41358 | k SEQUENCE{x2 NULL, | |
41359 | y2 BOOLEAN}, | |
41360 | ||
41361 | l SET { x3 BIT STRING, | |
41362 | y3 NULL}, | |
41363 | ||
41364 | m [3] SEQUENCE OF INTEGER, | |
41365 | n [4] SET OF BOOLEAN | |
41366 | } | |
41367 | ||
41368 | ||
41369 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
41370 | ||
41371 | ||
41372 | END | |
41373 | ||
41374 | <STATIC> | |
41375 | ||
41376 | import from TempA all; | |
41377 | ||
41378 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
41379 | ||
41380 | ||
41381 | const BERPDU myValue := {a := NULL, | |
41382 | b := true, | |
41383 | c := 2, | |
41384 | d := first, | |
41385 | // e := 1.0, 090603312E452B30 | |
41386 | f := '1'B, | |
41387 | g := 'FFFF'O, | |
41388 | h := myOBJID, | |
41389 | i := "ABC", | |
41390 | j := {x1 := true } , | |
41391 | k := {x2 := NULL, | |
41392 | ||
41393 | y2 := true } , | |
41394 | l := {y3 := NULL , | |
41395 | ||
41396 | x3 := '1'B } , | |
41397 | m := | |
41398 | { 1 ,2 } , | |
41399 | n := | |
41400 | { true, true } | |
41401 | } | |
41402 | ||
41403 | ||
41404 | ||
41405 | ||
41406 | ||
41407 | <TTCN_TC:EXEC> | |
41408 | ||
41409 | if (dec_BER_PDU('31800101FF0201020A0100030207800402FFFF050006030002031603414243A1800101FF0000308005000101FF000031800302078005000000A380308002010102010200000000A48031800101FF0101FF000000000000'O) == myValue) | |
41410 | ||
41411 | ||
41412 | ||
41413 | {setverdict(pass);} else {setverdict(fail);} | |
41414 | ||
41415 | ||
41416 | <RESULT> | |
41417 | ||
41418 | Overall verdict: pass | |
41419 | ||
41420 | <END_TC> | |
41421 | ||
41422 | :exmp. | |
41423 | ||
41424 | .*---------------------------------------------------------------------* | |
41425 | :h3. DECODING , DER, SET with fields of different types , AUTOMATIC TAGS | |
41426 | .*---------------------------------------------------------------------* | |
41427 | :xmp tab=0. | |
41428 | ||
41429 | <TC - DECODING , DER, SET with fields of different types , AUTOMATIC TAGS> | |
41430 | ||
41431 | <STATIC:ASN> | |
41432 | ||
41433 | TempA | |
41434 | ||
41435 | DEFINITIONS | |
41436 | AUTOMATIC TAGS | |
41437 | ||
41438 | ::= | |
41439 | ||
41440 | BEGIN | |
41441 | ||
41442 | ||
41443 | ||
41444 | BERPDU ::= SET | |
41445 | { | |
41446 | a NULL, | |
41447 | b BOOLEAN, | |
41448 | c INTEGER, | |
41449 | d ENUMERATED {first ,second ,third}, | |
41450 | e NULL, | |
41451 | f BIT STRING, | |
41452 | g OCTET STRING, | |
41453 | ||
41454 | h OBJECT IDENTIFIER, | |
41455 | i IA5String, | |
41456 | j CHOICE {x1 BOOLEAN, | |
41457 | y1 OCTET STRING}, | |
41458 | ||
41459 | k SEQUENCE{x2 NULL, | |
41460 | y2 BOOLEAN}, | |
41461 | ||
41462 | l SET { x3 BIT STRING, | |
41463 | y3 NULL}, | |
41464 | ||
41465 | m SEQUENCE OF INTEGER, | |
41466 | n SET OF BOOLEAN | |
41467 | } | |
41468 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
41469 | ||
41470 | ||
41471 | END | |
41472 | ||
41473 | <STATIC> | |
41474 | ||
41475 | import from TempA all; | |
41476 | ||
41477 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
41478 | ||
41479 | ||
41480 | const BERPDU myValue := {a := NULL, | |
41481 | b := true, | |
41482 | c := 2, | |
41483 | d := first, | |
41484 | e := NULL, | |
41485 | f := '1'B, | |
41486 | g := 'FFFF'O, | |
41487 | h := myOBJID, | |
41488 | i := "ABC", | |
41489 | j := {x1 := true } , | |
41490 | k := {x2 := NULL, | |
41491 | ||
41492 | y2 := true } , | |
41493 | l := {y3 := NULL , | |
41494 | ||
41495 | x3 := '1'B } , | |
41496 | m := | |
41497 | { 1 ,2 } , | |
41498 | n := | |
41499 | { true, true } | |
41500 | } | |
41501 | ||
41502 | ||
41503 | ||
41504 | ||
41505 | ||
41506 | ||
41507 | <TTCN_TC:EXEC> | |
41508 | ||
41509 | if (dec_BER_PDU('314380008101FF8201028301008400850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB06800207808100AC06020101020102AD060101FF0101FF'O) == myValue) | |
41510 | ||
41511 | ||
41512 | ||
41513 | {setverdict(pass);} else {setverdict(fail);} | |
41514 | ||
41515 | ||
41516 | <RESULT> | |
41517 | ||
41518 | Overall verdict: pass | |
41519 | ||
41520 | <END_TC> | |
41521 | ||
41522 | :exmp. | |
41523 | ||
41524 | .*---------------------------------------------------------------------* | |
41525 | :h3. DECODING , DER, SET with fields of different types ,AUTOMATIC TAGS | |
41526 | .*---------------------------------------------------------------------* | |
41527 | :xmp tab=0. | |
41528 | ||
41529 | <TC - DECODING , DER, SET with fields of different types ,AUTOMATIC TAGS> | |
41530 | ||
41531 | <STATIC:ASN> | |
41532 | ||
41533 | TempA | |
41534 | ||
41535 | DEFINITIONS | |
41536 | ||
41537 | AUTOMATIC TAGS | |
41538 | ::= | |
41539 | ||
41540 | BEGIN | |
41541 | ||
41542 | ||
41543 | BERPDU ::= SET | |
41544 | { | |
41545 | a NULL, | |
41546 | b BOOLEAN, | |
41547 | c INTEGER, | |
41548 | d ENUMERATED {first ,second ,third}, | |
41549 | e NULL, | |
41550 | f BIT STRING, | |
41551 | g OCTET STRING, | |
41552 | ||
41553 | h OBJECT IDENTIFIER, | |
41554 | i IA5String, | |
41555 | j CHOICE {x1 BOOLEAN, | |
41556 | y1 OCTET STRING}, | |
41557 | ||
41558 | k SEQUENCE{x2 NULL, | |
41559 | y2 BOOLEAN}, | |
41560 | ||
41561 | l SET { x3 BIT STRING, | |
41562 | y3 NULL}, | |
41563 | ||
41564 | m SEQUENCE OF INTEGER, | |
41565 | n SET OF BOOLEAN | |
41566 | } | |
41567 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
41568 | ||
41569 | ||
41570 | ||
41571 | END | |
41572 | ||
41573 | <STATIC> | |
41574 | ||
41575 | import from TempA all; | |
41576 | ||
41577 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
41578 | ||
41579 | ||
41580 | const BERPDU myValue := {a := NULL, | |
41581 | b := true, | |
41582 | c := 2, | |
41583 | d := first, | |
41584 | e := NULL, | |
41585 | f := '1'B, | |
41586 | g := 'FFFF'O, | |
41587 | h := myOBJID, | |
41588 | i := "ABC", | |
41589 | j := {x1 := true } , | |
41590 | k := {x2 := NULL, | |
41591 | ||
41592 | y2 := true } , | |
41593 | l := {y3 := NULL , | |
41594 | ||
41595 | x3 := '1'B } , | |
41596 | m := | |
41597 | { 1 ,2 } , | |
41598 | n := | |
41599 | { true, true } | |
41600 | } | |
41601 | ||
41602 | ||
41603 | ||
41604 | ||
41605 | ||
41606 | ||
41607 | <TTCN_TC:EXEC> | |
41608 | ||
41609 | if (dec_BER_PDU('318080008101FF8201028301008400850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB808002078081000000AC800201010201020000AD800101FF0101FF00000000'O) == myValue) | |
41610 | ||
41611 | ||
41612 | ||
41613 | {setverdict(pass);} else {setverdict(fail);} | |
41614 | ||
41615 | ||
41616 | <RESULT> | |
41617 | ||
41618 | Overall verdict: pass | |
41619 | ||
41620 | <END_TC> | |
41621 | ||
41622 | :exmp. | |
41623 | ||
41624 | .*---------------------------------------------------------------------* | |
41625 | :h3. DECODING , different order, SET with fields of different types , AUTOMATIC TAGS | |
41626 | .*---------------------------------------------------------------------* | |
41627 | :xmp tab=0. | |
41628 | ||
41629 | <TC - DECODING , different order, SET with fields of different types , AUTOMATIC TAGS> | |
41630 | ||
41631 | <STATIC:ASN> | |
41632 | ||
41633 | TempA | |
41634 | ||
41635 | DEFINITIONS | |
41636 | AUTOMATIC TAGS | |
41637 | ||
41638 | ::= | |
41639 | ||
41640 | BEGIN | |
41641 | ||
41642 | ||
41643 | ||
41644 | BERPDU ::= SET | |
41645 | { | |
41646 | a NULL, | |
41647 | b BOOLEAN, | |
41648 | c INTEGER, | |
41649 | d ENUMERATED {first ,second ,third}, | |
41650 | e NULL, | |
41651 | f BIT STRING, | |
41652 | g OCTET STRING, | |
41653 | ||
41654 | h OBJECT IDENTIFIER, | |
41655 | i IA5String, | |
41656 | j CHOICE {x1 BOOLEAN, | |
41657 | y1 OCTET STRING}, | |
41658 | ||
41659 | k SEQUENCE{x2 NULL, | |
41660 | y2 BOOLEAN}, | |
41661 | ||
41662 | l SET { x3 BIT STRING, | |
41663 | y3 NULL}, | |
41664 | ||
41665 | m SEQUENCE OF INTEGER, | |
41666 | n SET OF BOOLEAN | |
41667 | } | |
41668 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
41669 | ||
41670 | ||
41671 | END | |
41672 | ||
41673 | <STATIC> | |
41674 | ||
41675 | import from TempA all; | |
41676 | ||
41677 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
41678 | ||
41679 | ||
41680 | const BERPDU myValue := {a := NULL, | |
41681 | b := true, | |
41682 | c := 2, | |
41683 | d := first, | |
41684 | e := NULL, | |
41685 | f := '1'B, | |
41686 | g := 'FFFF'O, | |
41687 | h := myOBJID, | |
41688 | i := "ABC", | |
41689 | j := {x1 := true } , | |
41690 | k := {x2 := NULL, | |
41691 | ||
41692 | y2 := true } , | |
41693 | l := {y3 := NULL , | |
41694 | ||
41695 | x3 := '1'B } , | |
41696 | m := | |
41697 | { 1 ,2 } , | |
41698 | n := | |
41699 | { true, true } | |
41700 | } | |
41701 | ||
41702 | ||
41703 | ||
41704 | ||
41705 | ||
41706 | ||
41707 | <TTCN_TC:EXEC> | |
41708 | ||
41709 | if (dec_BER_PDU('31438101FF8201028301008400850207808602FFFF87030002038803414243A9038001FFAA0580008101FFAB06800207808100AC06020101020102AD060101FF0101FF8000'O) == myValue) | |
41710 | ||
41711 | ||
41712 | ||
41713 | {setverdict(pass);} else {setverdict(fail);} | |
41714 | ||
41715 | ||
41716 | <RESULT> | |
41717 | ||
41718 | Overall verdict: pass | |
41719 | ||
41720 | <END_TC> | |
41721 | ||
41722 | :exmp. | |
41723 | ||
41724 | .*---------------------------------------------------------------------* | |
41725 | :h3. DECODING , different order, SET with fields of different types ,AUTOMATIC TAGS | |
41726 | .*---------------------------------------------------------------------* | |
41727 | :xmp tab=0. | |
41728 | ||
41729 | <TC - DECODING , different order, SET with fields of different types ,AUTOMATIC TAGS> | |
41730 | ||
41731 | <STATIC:ASN> | |
41732 | ||
41733 | TempA | |
41734 | ||
41735 | DEFINITIONS | |
41736 | ||
41737 | AUTOMATIC TAGS | |
41738 | ::= | |
41739 | ||
41740 | BEGIN | |
41741 | ||
41742 | ||
41743 | BERPDU ::= SET | |
41744 | { | |
41745 | a NULL, | |
41746 | b BOOLEAN, | |
41747 | c INTEGER, | |
41748 | d ENUMERATED {first ,second ,third}, | |
41749 | e NULL, | |
41750 | f BIT STRING, | |
41751 | g OCTET STRING, | |
41752 | ||
41753 | h OBJECT IDENTIFIER, | |
41754 | i IA5String, | |
41755 | j CHOICE {x1 BOOLEAN, | |
41756 | y1 OCTET STRING}, | |
41757 | ||
41758 | k SEQUENCE{x2 NULL, | |
41759 | y2 BOOLEAN}, | |
41760 | ||
41761 | l SET { x3 BIT STRING, | |
41762 | y3 NULL}, | |
41763 | ||
41764 | m SEQUENCE OF INTEGER, | |
41765 | n SET OF BOOLEAN | |
41766 | } | |
41767 | myOBJID OBJECT IDENTIFIER ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
41768 | ||
41769 | ||
41770 | ||
41771 | END | |
41772 | ||
41773 | <STATIC> | |
41774 | ||
41775 | import from TempA all; | |
41776 | ||
41777 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
41778 | ||
41779 | ||
41780 | const BERPDU myValue := {a := NULL, | |
41781 | b := true, | |
41782 | c := 2, | |
41783 | d := first, | |
41784 | e := NULL, | |
41785 | f := '1'B, | |
41786 | g := 'FFFF'O, | |
41787 | h := myOBJID, | |
41788 | i := "ABC", | |
41789 | j := {x1 := true } , | |
41790 | k := {x2 := NULL, | |
41791 | ||
41792 | y2 := true } , | |
41793 | l := {y3 := NULL , | |
41794 | ||
41795 | x3 := '1'B } , | |
41796 | m := | |
41797 | { 1 ,2 } , | |
41798 | n := | |
41799 | { true, true } | |
41800 | } | |
41801 | ||
41802 | ||
41803 | ||
41804 | ||
41805 | ||
41806 | ||
41807 | <TTCN_TC:EXEC> | |
41808 | ||
41809 | if (dec_BER_PDU('318080008201028101FF8301008400850207808602FFFF87030002038803414243A9808001FF0000AA8080008101FF0000AB808002078081000000AC800201010201020000AD800101FF0101FF00000000'O) == myValue) | |
41810 | ||
41811 | ||
41812 | ||
41813 | {setverdict(pass);} else {setverdict(fail);} | |
41814 | ||
41815 | ||
41816 | <RESULT> | |
41817 | ||
41818 | Overall verdict: pass | |
41819 | ||
41820 | <END_TC> | |
41821 | ||
41822 | :exmp. | |
41823 | ||
41824 | .*---------------------------------------------------------------------* | |
41825 | :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGS | |
41826 | .*---------------------------------------------------------------------* | |
41827 | :xmp tab=0. | |
41828 | ||
41829 | <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGS> | |
41830 | ||
41831 | <STATIC:ASN> | |
41832 | ||
41833 | TempA | |
41834 | ||
41835 | DEFINITIONS | |
41836 | ||
41837 | IMPLICIT TAGS | |
41838 | ::= | |
41839 | ||
41840 | BEGIN | |
41841 | ||
41842 | ||
41843 | ||
41844 | BERPDU ::= SET | |
41845 | { | |
41846 | d [PRIVATE 0] INTEGER OPTIONAL, | |
41847 | a INTEGER OPTIONAL, | |
41848 | b [APPLICATION 0] INTEGER OPTIONAL, | |
41849 | c [0] INTEGER OPTIONAL | |
41850 | ||
41851 | } | |
41852 | ||
41853 | ||
41854 | ||
41855 | END | |
41856 | ||
41857 | <STATIC> | |
41858 | ||
41859 | import from TempA all; | |
41860 | ||
41861 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
41862 | ||
41863 | ||
41864 | const BERPDU myValue := { | |
41865 | a := 1, | |
41866 | c := 3, | |
41867 | d := 4, | |
41868 | b := 2 } | |
41869 | ||
41870 | ||
41871 | ||
41872 | <TTCN_TC:EXEC> | |
41873 | ||
41874 | if (dec_BER_PDU('310C020101400102800103C00104'O) == myValue) | |
41875 | ||
41876 | {setverdict(pass);} else {setverdict(fail);} | |
41877 | ||
41878 | ||
41879 | <RESULT> | |
41880 | ||
41881 | Overall verdict: pass | |
41882 | ||
41883 | <END_TC> | |
41884 | ||
41885 | :exmp. | |
41886 | ||
41887 | .*---------------------------------------------------------------------* | |
41888 | :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGS | |
41889 | .*---------------------------------------------------------------------* | |
41890 | :xmp tab=0. | |
41891 | ||
41892 | <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) IMPLICIT TAGS> | |
41893 | ||
41894 | <STATIC:ASN> | |
41895 | ||
41896 | TempA | |
41897 | ||
41898 | DEFINITIONS | |
41899 | ||
41900 | IMPLICIT TAGS | |
41901 | ::= | |
41902 | ||
41903 | BEGIN | |
41904 | ||
41905 | ||
41906 | ||
41907 | BERPDU ::= SET | |
41908 | { | |
41909 | d [PRIVATE 0] INTEGER OPTIONAL, | |
41910 | a INTEGER OPTIONAL, | |
41911 | b [APPLICATION 0] INTEGER OPTIONAL, | |
41912 | c [0] INTEGER OPTIONAL | |
41913 | ||
41914 | } | |
41915 | ||
41916 | ||
41917 | ||
41918 | END | |
41919 | ||
41920 | <STATIC> | |
41921 | ||
41922 | import from TempA all; | |
41923 | ||
41924 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
41925 | ||
41926 | ||
41927 | const BERPDU myValue := { | |
41928 | a := 1, | |
41929 | c := 3, | |
41930 | d := 4, | |
41931 | b := 2 } | |
41932 | ||
41933 | ||
41934 | ||
41935 | <TTCN_TC:EXEC> | |
41936 | ||
41937 | if (dec_BER_PDU('3180020101400102800103C001040000'O) == myValue) | |
41938 | ||
41939 | {setverdict(pass);} else {setverdict(fail);} | |
41940 | ||
41941 | ||
41942 | <RESULT> | |
41943 | ||
41944 | Overall verdict: pass | |
41945 | ||
41946 | <END_TC> | |
41947 | ||
41948 | :exmp. | |
41949 | ||
41950 | .*---------------------------------------------------------------------* | |
41951 | :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) | |
41952 | .*---------------------------------------------------------------------* | |
41953 | :xmp tab=0. | |
41954 | ||
41955 | <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )> | |
41956 | ||
41957 | <STATIC:ASN> | |
41958 | ||
41959 | TempA | |
41960 | ||
41961 | DEFINITIONS ::= | |
41962 | BEGIN | |
41963 | ||
41964 | ||
41965 | ||
41966 | BERPDU ::= SET | |
41967 | { | |
41968 | d [PRIVATE 0] INTEGER OPTIONAL, | |
41969 | a INTEGER OPTIONAL, | |
41970 | b [APPLICATION 0] INTEGER OPTIONAL, | |
41971 | c [0] INTEGER OPTIONAL | |
41972 | ||
41973 | } | |
41974 | ||
41975 | ||
41976 | ||
41977 | END | |
41978 | ||
41979 | <STATIC> | |
41980 | ||
41981 | import from TempA all; | |
41982 | ||
41983 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
41984 | ||
41985 | ||
41986 | const BERPDU myValue := { | |
41987 | a := 1, | |
41988 | c := 3, | |
41989 | d := 4, | |
41990 | b := 2 } | |
41991 | ||
41992 | ||
41993 | ||
41994 | <TTCN_TC:EXEC> | |
41995 | ||
41996 | if (dec_BER_PDU('31120201016003020102A003020103E003020104'O) == myValue) | |
41997 | ||
41998 | {setverdict(pass);} else {setverdict(fail);} | |
41999 | ||
42000 | ||
42001 | <RESULT> | |
42002 | ||
42003 | Overall verdict: pass | |
42004 | ||
42005 | <END_TC> | |
42006 | ||
42007 | :exmp. | |
42008 | ||
42009 | .*---------------------------------------------------------------------* | |
42010 | :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) | |
42011 | .*---------------------------------------------------------------------* | |
42012 | :xmp tab=0. | |
42013 | ||
42014 | <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE )> | |
42015 | ||
42016 | <STATIC:ASN> | |
42017 | ||
42018 | TempA | |
42019 | ||
42020 | DEFINITIONS ::= | |
42021 | BEGIN | |
42022 | ||
42023 | ||
42024 | ||
42025 | BERPDU ::= SET | |
42026 | { | |
42027 | d [PRIVATE 0] INTEGER OPTIONAL, | |
42028 | a INTEGER OPTIONAL, | |
42029 | b [APPLICATION 0] INTEGER OPTIONAL, | |
42030 | c [0] INTEGER OPTIONAL | |
42031 | ||
42032 | } | |
42033 | ||
42034 | ||
42035 | ||
42036 | END | |
42037 | ||
42038 | <STATIC> | |
42039 | ||
42040 | import from TempA all; | |
42041 | ||
42042 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
42043 | ||
42044 | ||
42045 | const BERPDU myValue := { | |
42046 | a := 1, | |
42047 | c := 3, | |
42048 | d := 4, | |
42049 | b := 2 } | |
42050 | ||
42051 | ||
42052 | ||
42053 | <TTCN_TC:EXEC> | |
42054 | ||
42055 | if (dec_BER_PDU('318002010160800201020000A0800201030000E08002010400000000'O) == myValue) | |
42056 | ||
42057 | {setverdict(pass);} else {setverdict(fail);} | |
42058 | ||
42059 | ||
42060 | <RESULT> | |
42061 | ||
42062 | Overall verdict: pass | |
42063 | ||
42064 | <END_TC> | |
42065 | ||
42066 | :exmp. | |
42067 | ||
42068 | .*---------------------------------------------------------------------* | |
42069 | :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGS | |
42070 | .*---------------------------------------------------------------------* | |
42071 | :xmp tab=0. | |
42072 | ||
42073 | <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGS> | |
42074 | ||
42075 | <STATIC:ASN> | |
42076 | ||
42077 | TempA | |
42078 | ||
42079 | DEFINITIONS | |
42080 | ||
42081 | EXPLICIT TAGS | |
42082 | ||
42083 | ||
42084 | ::= | |
42085 | ||
42086 | BEGIN | |
42087 | ||
42088 | ||
42089 | ||
42090 | BERPDU ::= SET | |
42091 | { | |
42092 | d [PRIVATE 0] INTEGER OPTIONAL, | |
42093 | a INTEGER OPTIONAL, | |
42094 | b [APPLICATION 0] INTEGER OPTIONAL, | |
42095 | c [0] INTEGER OPTIONAL | |
42096 | ||
42097 | } | |
42098 | ||
42099 | ||
42100 | ||
42101 | END | |
42102 | ||
42103 | <STATIC> | |
42104 | ||
42105 | import from TempA all; | |
42106 | ||
42107 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
42108 | ||
42109 | ||
42110 | const BERPDU myValue := { | |
42111 | a := 1, | |
42112 | c := 3, | |
42113 | d := 4, | |
42114 | b := 2 } | |
42115 | ||
42116 | ||
42117 | ||
42118 | <TTCN_TC:EXEC> | |
42119 | ||
42120 | if (dec_BER_PDU('31120201016003020102A003020103E003020104'O) == myValue) | |
42121 | ||
42122 | {setverdict(pass);} else {setverdict(fail);} | |
42123 | ||
42124 | ||
42125 | <RESULT> | |
42126 | ||
42127 | Overall verdict: pass | |
42128 | ||
42129 | <END_TC> | |
42130 | ||
42131 | :exmp. | |
42132 | ||
42133 | .*---------------------------------------------------------------------* | |
42134 | :h3. DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGGING | |
42135 | .*---------------------------------------------------------------------* | |
42136 | :xmp tab=0. | |
42137 | ||
42138 | <TC - DECODING SET, DER, (include UNIVERSAL, APPLICATION, CONTEXT SPECIFIC, PRIVATE ) EXPLICIT TAGGING> | |
42139 | ||
42140 | <STATIC:ASN> | |
42141 | ||
42142 | TempA | |
42143 | ||
42144 | DEFINITIONS | |
42145 | ||
42146 | EXPLICIT TAGS | |
42147 | ||
42148 | ::= | |
42149 | ||
42150 | BEGIN | |
42151 | ||
42152 | ||
42153 | ||
42154 | BERPDU ::= SET | |
42155 | { | |
42156 | d [PRIVATE 0] INTEGER OPTIONAL, | |
42157 | a INTEGER OPTIONAL, | |
42158 | b [APPLICATION 0] INTEGER OPTIONAL, | |
42159 | c [0] INTEGER OPTIONAL | |
42160 | ||
42161 | } | |
42162 | ||
42163 | ||
42164 | ||
42165 | END | |
42166 | ||
42167 | <STATIC> | |
42168 | ||
42169 | import from TempA all; | |
42170 | ||
42171 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
42172 | ||
42173 | ||
42174 | const BERPDU myValue := { | |
42175 | a := 1, | |
42176 | c := 3, | |
42177 | d := 4, | |
42178 | b := 2 } | |
42179 | ||
42180 | ||
42181 | ||
42182 | <TTCN_TC:EXEC> | |
42183 | ||
42184 | if (dec_BER_PDU('318002010160800201020000A0800201030000E08002010400000000'O) == myValue) | |
42185 | ||
42186 | {setverdict(pass);} else {setverdict(fail);} | |
42187 | ||
42188 | ||
42189 | <RESULT> | |
42190 | ||
42191 | Overall verdict: pass | |
42192 | ||
42193 | <END_TC> | |
42194 | ||
42195 | :exmp. | |
42196 | ||
42197 | .*---------------------------------------------------------------------* | |
42198 | :h3. DECODING SET, DER, untagged CHOICE in SET | |
42199 | .*---------------------------------------------------------------------* | |
42200 | :xmp tab=0. | |
42201 | ||
42202 | <TC - DECODING SET, DER, untagged CHOICE in SET> | |
42203 | ||
42204 | <STATIC:ASN> | |
42205 | ||
42206 | TempA | |
42207 | ||
42208 | DEFINITIONS | |
42209 | ||
42210 | IMPLICIT TAGS | |
42211 | ||
42212 | ::= | |
42213 | ||
42214 | BEGIN | |
42215 | ||
42216 | ||
42217 | ||
42218 | ||
42219 | BERPDU ::= SET | |
42220 | { | |
42221 | a [3] INTEGER, | |
42222 | b [1] CHOICE | |
42223 | { | |
42224 | c [2] INTEGER, | |
42225 | d [4] INTEGER | |
42226 | }, | |
42227 | e CHOICE | |
42228 | { | |
42229 | f CHOICE | |
42230 | { | |
42231 | g [5] INTEGER, | |
42232 | h [6] INTEGER | |
42233 | }, | |
42234 | i CHOICE | |
42235 | { | |
42236 | ||
42237 | ||
42238 | j [0] INTEGER | |
42239 | ||
42240 | } | |
42241 | } | |
42242 | } | |
42243 | ||
42244 | ||
42245 | ||
42246 | ||
42247 | END | |
42248 | ||
42249 | <STATIC> | |
42250 | ||
42251 | import from TempA all; | |
42252 | ||
42253 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
42254 | ||
42255 | ||
42256 | ||
42257 | ||
42258 | const BERPDU myValue := { | |
42259 | a := 1, | |
42260 | b := {c:= 2}, | |
42261 | e := { f := {g := 3 }} | |
42262 | } | |
42263 | ||
42264 | ||
42265 | ||
42266 | <TTCN_TC:EXEC> | |
42267 | ||
42268 | if (dec_BER_PDU('310BA103820102830101850103'O) == myValue) | |
42269 | ||
42270 | {setverdict(pass);} else {setverdict(fail);} | |
42271 | ||
42272 | ||
42273 | <RESULT> | |
42274 | ||
42275 | Overall verdict: pass | |
42276 | ||
42277 | <END_TC> | |
42278 | ||
42279 | :exmp. | |
42280 | ||
42281 | .*---------------------------------------------------------------------* | |
42282 | :h3. DECODING SET, CER, untagged CHOICE in SET | |
42283 | .*---------------------------------------------------------------------* | |
42284 | :xmp tab=0. | |
42285 | ||
42286 | <TC - DECODING SET, CER, untagged CHOICE in SET> | |
42287 | ||
42288 | <STATIC:ASN> | |
42289 | ||
42290 | TempA | |
42291 | ||
42292 | DEFINITIONS | |
42293 | ||
42294 | IMPLICIT TAGS | |
42295 | ||
42296 | ::= | |
42297 | ||
42298 | BEGIN | |
42299 | ||
42300 | ||
42301 | ||
42302 | ||
42303 | BERPDU ::= SET | |
42304 | { | |
42305 | a [3] INTEGER, | |
42306 | b [1] CHOICE | |
42307 | { | |
42308 | c [2] INTEGER, | |
42309 | d [4] INTEGER | |
42310 | }, | |
42311 | e CHOICE | |
42312 | { | |
42313 | f CHOICE | |
42314 | { | |
42315 | g [5] INTEGER, | |
42316 | h [6] INTEGER | |
42317 | }, | |
42318 | i CHOICE | |
42319 | { | |
42320 | ||
42321 | ||
42322 | j [0] INTEGER | |
42323 | ||
42324 | } | |
42325 | } | |
42326 | } | |
42327 | ||
42328 | ||
42329 | ||
42330 | ||
42331 | END | |
42332 | ||
42333 | <STATIC> | |
42334 | ||
42335 | import from TempA all; | |
42336 | ||
42337 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
42338 | ||
42339 | ||
42340 | ||
42341 | ||
42342 | const BERPDU myValue := { | |
42343 | a := 1, | |
42344 | b := {c:= 2}, | |
42345 | e := { f := {g := 3 }} | |
42346 | } | |
42347 | ||
42348 | ||
42349 | ||
42350 | <TTCN_TC:EXEC> | |
42351 | ||
42352 | if (dec_BER_PDU('3180850103A18082010200008301010000'O) == myValue) | |
42353 | ||
42354 | {setverdict(pass);} else {setverdict(fail);} | |
42355 | ||
42356 | ||
42357 | <RESULT> | |
42358 | ||
42359 | Overall verdict: pass | |
42360 | ||
42361 | <END_TC> | |
42362 | ||
42363 | :exmp. | |
42364 | ||
42365 | .*---------------------------------------------------------------------* | |
42366 | :h3. DECODING SET, DER, untagged CHOICE in SET, EXPLICIT TAGS | |
42367 | .*---------------------------------------------------------------------* | |
42368 | :xmp tab=0. | |
42369 | ||
42370 | <TC - DECODING SET, DER, untagged CHOICE in SET, EXPLICIT TAGS> | |
42371 | ||
42372 | <STATIC:ASN> | |
42373 | ||
42374 | TempA | |
42375 | ||
42376 | DEFINITIONS | |
42377 | ||
42378 | EXPLICIT TAGS | |
42379 | ||
42380 | ::= | |
42381 | ||
42382 | BEGIN | |
42383 | ||
42384 | ||
42385 | ||
42386 | ||
42387 | BERPDU ::= SET | |
42388 | { | |
42389 | a [3] INTEGER, | |
42390 | b [1] CHOICE | |
42391 | { | |
42392 | c [2] INTEGER, | |
42393 | d [4] INTEGER | |
42394 | }, | |
42395 | e CHOICE | |
42396 | { | |
42397 | f CHOICE | |
42398 | { | |
42399 | g [5] INTEGER, | |
42400 | h [6] INTEGER | |
42401 | }, | |
42402 | i CHOICE | |
42403 | { | |
42404 | ||
42405 | ||
42406 | j [0] INTEGER | |
42407 | ||
42408 | } | |
42409 | } | |
42410 | } | |
42411 | ||
42412 | ||
42413 | ||
42414 | ||
42415 | END | |
42416 | ||
42417 | <STATIC> | |
42418 | ||
42419 | import from TempA all; | |
42420 | ||
42421 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
42422 | ||
42423 | ||
42424 | ||
42425 | ||
42426 | const BERPDU myValue := { | |
42427 | a := 1, | |
42428 | b := {c:= 2}, | |
42429 | e := { f := {g := 3 }} | |
42430 | } | |
42431 | ||
42432 | ||
42433 | ||
42434 | <TTCN_TC:EXEC> | |
42435 | ||
42436 | if (dec_BER_PDU('3111A105A203020102A303020101A503020103'O) == myValue) | |
42437 | ||
42438 | {setverdict(pass);} else {setverdict(fail);} | |
42439 | ||
42440 | ||
42441 | <RESULT> | |
42442 | ||
42443 | Overall verdict: pass | |
42444 | ||
42445 | <END_TC> | |
42446 | ||
42447 | :exmp. | |
42448 | ||
42449 | .*---------------------------------------------------------------------* | |
42450 | :h3. DECODING SET, CER, untagged CHOICE in SET, EXPLICIT TAGS | |
42451 | .*---------------------------------------------------------------------* | |
42452 | :xmp tab=0. | |
42453 | ||
42454 | <TC - DECODING SET, CER, untagged CHOICE in SET, EXPLICIT TAGS> | |
42455 | ||
42456 | <STATIC:ASN> | |
42457 | ||
42458 | TempA | |
42459 | ||
42460 | DEFINITIONS | |
42461 | ||
42462 | EXPLICIT TAGS | |
42463 | ||
42464 | ::= | |
42465 | ||
42466 | BEGIN | |
42467 | ||
42468 | ||
42469 | ||
42470 | ||
42471 | BERPDU ::= SET | |
42472 | { | |
42473 | a [3] INTEGER, | |
42474 | b [1] CHOICE | |
42475 | { | |
42476 | c [2] INTEGER, | |
42477 | d [4] INTEGER | |
42478 | }, | |
42479 | e CHOICE | |
42480 | { | |
42481 | f CHOICE | |
42482 | { | |
42483 | g [5] INTEGER, | |
42484 | h [6] INTEGER | |
42485 | }, | |
42486 | i CHOICE | |
42487 | { | |
42488 | ||
42489 | ||
42490 | j [0] INTEGER | |
42491 | ||
42492 | } | |
42493 | } | |
42494 | } | |
42495 | ||
42496 | ||
42497 | ||
42498 | ||
42499 | END | |
42500 | ||
42501 | <STATIC> | |
42502 | ||
42503 | import from TempA all; | |
42504 | ||
42505 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
42506 | ||
42507 | ||
42508 | ||
42509 | ||
42510 | const BERPDU myValue := { | |
42511 | a := 1, | |
42512 | b := {c:= 2}, | |
42513 | e := { f := {g := 3 }} | |
42514 | } | |
42515 | ||
42516 | ||
42517 | ||
42518 | <TTCN_TC:EXEC> | |
42519 | ||
42520 | if (dec_BER_PDU('3180A5800201030000A180A28002010200000000A38002010100000000'O) == myValue) | |
42521 | ||
42522 | {setverdict(pass);} else {setverdict(fail);} | |
42523 | ||
42524 | ||
42525 | <RESULT> | |
42526 | ||
42527 | Overall verdict: pass | |
42528 | ||
42529 | <END_TC> | |
42530 | ||
42531 | :exmp. | |
42532 | ||
42533 | .*---------------------------------------------------------------------* | |
42534 | :h3.CER + DER encoding of SET OF INTEGER (empty) | |
42535 | .*---------------------------------------------------------------------* | |
42536 | :xmp tab=0. | |
42537 | ||
42538 | <TC - CER + DER encoding of SET OF INTEGER (empty)> | |
42539 | ||
42540 | <STATIC:ASN> | |
42541 | ||
42542 | TempA | |
42543 | ||
42544 | DEFINITIONS ::= | |
42545 | BEGIN | |
42546 | ||
42547 | BERPDU ::= SET OF INTEGER | |
42548 | ||
42549 | ||
42550 | ||
42551 | END | |
42552 | ||
42553 | <STATIC> | |
42554 | ||
42555 | import from TempA all; | |
42556 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
42557 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
42558 | ||
42559 | const BERPDU myValue := { } | |
42560 | ||
42561 | <TTCN_TC:EXEC> | |
42562 | ||
42563 | ||
42564 | ||
42565 | ||
42566 | if ((enc_DER_PDU(myValue) == '3100'O)and(enc_CER_PDU(myValue) == '31800000'O)) {setverdict(pass);} else {setverdict(fail);} | |
42567 | ||
42568 | <RESULT> | |
42569 | ||
42570 | Overall verdict: pass | |
42571 | ||
42572 | <END_TC> | |
42573 | ||
42574 | :exmp. | |
42575 | ||
42576 | .*---------------------------------------------------------------------* | |
42577 | :h3.CER + DER encoding of SET OF BOOLEAN | |
42578 | .*---------------------------------------------------------------------* | |
42579 | :xmp tab=0. | |
42580 | ||
42581 | <TC - CER + DER encoding of SET OF BOOLEAN> | |
42582 | ||
42583 | <STATIC:ASN> | |
42584 | ||
42585 | TempA | |
42586 | ||
42587 | DEFINITIONS ::= | |
42588 | BEGIN | |
42589 | ||
42590 | BERPDU ::= SET OF BOOLEAN | |
42591 | ||
42592 | ||
42593 | ||
42594 | END | |
42595 | ||
42596 | <STATIC> | |
42597 | ||
42598 | import from TempA all; | |
42599 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
42600 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
42601 | ||
42602 | const BERPDU myValue := {true, false } | |
42603 | ||
42604 | <TTCN_TC:EXEC> | |
42605 | ||
42606 | ||
42607 | ||
42608 | ||
42609 | if ((enc_DER_PDU(myValue) == '31060101000101FF'O)and(enc_CER_PDU(myValue) == '31800101000101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
42610 | ||
42611 | <RESULT> | |
42612 | ||
42613 | Overall verdict: pass | |
42614 | ||
42615 | <END_TC> | |
42616 | ||
42617 | :exmp. | |
42618 | ||
42619 | .*---------------------------------------------------------------------* | |
42620 | :h3.CER + DER encoding of SET OF OCTET STRING | |
42621 | .*---------------------------------------------------------------------* | |
42622 | :xmp tab=0. | |
42623 | ||
42624 | <TC - CER + DER encoding of SET OF OCTET STRING > | |
42625 | ||
42626 | <STATIC:ASN> | |
42627 | ||
42628 | TempA | |
42629 | ||
42630 | DEFINITIONS ::= | |
42631 | BEGIN | |
42632 | ||
42633 | BERPDU ::= SET OF OCTET STRING | |
42634 | ||
42635 | END | |
42636 | ||
42637 | <STATIC> | |
42638 | ||
42639 | import from TempA all; | |
42640 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
42641 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
42642 | ||
42643 | const BERPDU myValue := {'FFFF'O, 'AB'O }; | |
42644 | ||
42645 | <TTCN_TC:EXEC> | |
42646 | ||
42647 | if ((enc_DER_PDU(myValue) == '31070401AB0402FFFF'O)and(enc_CER_PDU(myValue) == '31800401AB0402FFFF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
42648 | ||
42649 | <RESULT> | |
42650 | ||
42651 | Overall verdict: pass | |
42652 | ||
42653 | <END_TC> | |
42654 | ||
42655 | :exmp. | |
42656 | ||
42657 | .*---------------------------------------------------------------------* | |
42658 | :h3.CER + DER encoding of SET OF SEQUENCE | |
42659 | .*---------------------------------------------------------------------* | |
42660 | :xmp tab=0. | |
42661 | ||
42662 | <TC - CER + DER encoding of SET OF SEQUENCE > | |
42663 | ||
42664 | <STATIC:ASN> | |
42665 | ||
42666 | TempA | |
42667 | ||
42668 | DEFINITIONS ::= | |
42669 | BEGIN | |
42670 | ||
42671 | BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN} | |
42672 | ||
42673 | END | |
42674 | ||
42675 | <STATIC> | |
42676 | ||
42677 | import from TempA all; | |
42678 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
42679 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
42680 | ||
42681 | const BERPDU myValue := { | |
42682 | { | |
42683 | a := 5, | |
42684 | b := true | |
42685 | }, | |
42686 | ||
42687 | { | |
42688 | a := 3, | |
42689 | b := false | |
42690 | } | |
42691 | ||
42692 | }; | |
42693 | ||
42694 | <TTCN_TC:EXEC> | |
42695 | ||
42696 | if ((enc_DER_PDU(myValue) == '3110300602010301010030060201050101FF'O)and(enc_CER_PDU(myValue) == '31803080020103010100000030800201050101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
42697 | ||
42698 | <RESULT> | |
42699 | ||
42700 | Overall verdict: pass | |
42701 | ||
42702 | <END_TC> | |
42703 | ||
42704 | :exmp. | |
42705 | ||
42706 | .*---------------------------------------------------------------------* | |
42707 | :h3.CER + DER encoding of SET OF SET | |
42708 | .*---------------------------------------------------------------------* | |
42709 | :xmp tab=0. | |
42710 | ||
42711 | <TC - CER + DER encoding of SET OF SET > | |
42712 | ||
42713 | <STATIC:ASN> | |
42714 | ||
42715 | TempA | |
42716 | ||
42717 | DEFINITIONS ::= | |
42718 | BEGIN | |
42719 | ||
42720 | BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN} | |
42721 | ||
42722 | END | |
42723 | ||
42724 | <STATIC> | |
42725 | ||
42726 | import from TempA all; | |
42727 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
42728 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
42729 | ||
42730 | const BERPDU myValue := { | |
42731 | { | |
42732 | a := 5, | |
42733 | b := true | |
42734 | }, | |
42735 | ||
42736 | { | |
42737 | a := 3, | |
42738 | b := false | |
42739 | } | |
42740 | ||
42741 | }; | |
42742 | ||
42743 | <TTCN_TC:EXEC> | |
42744 | ||
42745 | if ((enc_DER_PDU(myValue) == '3110310601010002010331060101FF020105'O)and(enc_CER_PDU(myValue) == '31803180010100020103000031800101FF02010500000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
42746 | ||
42747 | <RESULT> | |
42748 | ||
42749 | Overall verdict: pass | |
42750 | ||
42751 | <END_TC> | |
42752 | ||
42753 | :exmp. | |
42754 | ||
42755 | .*---------------------------------------------------------------------* | |
42756 | :h3.CER + DER encoding of SET OF CHOICE | |
42757 | .*---------------------------------------------------------------------* | |
42758 | :xmp tab=0. | |
42759 | ||
42760 | <TC - CER + DER encoding of SET OF CHOICE > | |
42761 | ||
42762 | <STATIC:ASN> | |
42763 | ||
42764 | TempA | |
42765 | ||
42766 | DEFINITIONS ::= | |
42767 | BEGIN | |
42768 | ||
42769 | BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN} | |
42770 | ||
42771 | END | |
42772 | ||
42773 | <STATIC> | |
42774 | ||
42775 | import from TempA all; | |
42776 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
42777 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
42778 | ||
42779 | const BERPDU myValue := { | |
42780 | { | |
42781 | a := 5 | |
42782 | }, | |
42783 | ||
42784 | { | |
42785 | b := false | |
42786 | } | |
42787 | ||
42788 | }; | |
42789 | ||
42790 | <TTCN_TC:EXEC> | |
42791 | ||
42792 | if ((enc_DER_PDU(myValue) == '3106010100020105'O)and(enc_CER_PDU(myValue) == '31800101000201050000'O)) {setverdict(pass);} else {setverdict(fail);} | |
42793 | ||
42794 | <RESULT> | |
42795 | ||
42796 | Overall verdict: pass | |
42797 | ||
42798 | <END_TC> | |
42799 | ||
42800 | :exmp. | |
42801 | ||
42802 | .*---------------------------------------------------------------------* | |
42803 | :h3.CER + DER encoding of SET OF SEQUENCE OF | |
42804 | .*---------------------------------------------------------------------* | |
42805 | :xmp tab=0. | |
42806 | ||
42807 | <TC - CER + DER encoding of SET OF SEQUENCE OF> | |
42808 | ||
42809 | <STATIC:ASN> | |
42810 | ||
42811 | TempA | |
42812 | ||
42813 | DEFINITIONS ::= | |
42814 | BEGIN | |
42815 | ||
42816 | BERPDU ::= SET OF SEQUENCE OF INTEGER | |
42817 | ||
42818 | END | |
42819 | ||
42820 | <STATIC> | |
42821 | ||
42822 | import from TempA all; | |
42823 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
42824 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
42825 | ||
42826 | const BERPDU myValue := { | |
42827 | { | |
42828 | 5, | |
42829 | 6, | |
42830 | 7 | |
42831 | }, | |
42832 | ||
42833 | { | |
42834 | 1, | |
42835 | 2, | |
42836 | 3 | |
42837 | } | |
42838 | }; | |
42839 | ||
42840 | <TTCN_TC:EXEC> | |
42841 | ||
42842 | if ((enc_DER_PDU(myValue) == '311630090201010201020201033009020105020106020107'O)and(enc_CER_PDU(myValue) == '318030800201010201020201030000308002010502010602010700000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
42843 | ||
42844 | <RESULT> | |
42845 | ||
42846 | Overall verdict: pass | |
42847 | ||
42848 | <END_TC> | |
42849 | ||
42850 | :exmp. | |
42851 | ||
42852 | .*---------------------------------------------------------------------* | |
42853 | :h3.CER + DER encoding of SET OF SET OF | |
42854 | .*---------------------------------------------------------------------* | |
42855 | :xmp tab=0. | |
42856 | ||
42857 | <TC - CER + DER encoding of SET OF SET OF> | |
42858 | ||
42859 | <STATIC:ASN> | |
42860 | ||
42861 | TempA | |
42862 | ||
42863 | DEFINITIONS ::= | |
42864 | BEGIN | |
42865 | ||
42866 | BERPDU ::= SET OF SET OF INTEGER | |
42867 | ||
42868 | END | |
42869 | ||
42870 | <STATIC> | |
42871 | ||
42872 | import from TempA all; | |
42873 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
42874 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
42875 | ||
42876 | const BERPDU myValue := { | |
42877 | { | |
42878 | 5, | |
42879 | 6, | |
42880 | 7 | |
42881 | }, | |
42882 | ||
42883 | { | |
42884 | 1, | |
42885 | 2, | |
42886 | 3 | |
42887 | } | |
42888 | }; | |
42889 | ||
42890 | <TTCN_TC:EXEC> | |
42891 | ||
42892 | if ((enc_DER_PDU(myValue) == '311631090201010201020201033109020105020106020107'O)and(enc_CER_PDU(myValue) == '318031800201010201020201030000318002010502010602010700000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
42893 | ||
42894 | <RESULT> | |
42895 | ||
42896 | Overall verdict: pass | |
42897 | ||
42898 | <END_TC> | |
42899 | ||
42900 | :exmp. | |
42901 | ||
42902 | .*---------------------------------------------------------------------* | |
42903 | :h3.CER + DER encoding of TAGGED SET OF BOOLEAN | |
42904 | .*---------------------------------------------------------------------* | |
42905 | :xmp tab=0. | |
42906 | ||
42907 | <TC - CER + DER encoding of TAGGED SET OF BOOLEAN> | |
42908 | ||
42909 | <STATIC:ASN> | |
42910 | ||
42911 | TempA | |
42912 | ||
42913 | DEFINITIONS ::= | |
42914 | BEGIN | |
42915 | ||
42916 | BERPDU ::= [0] SET OF BOOLEAN | |
42917 | ||
42918 | ||
42919 | ||
42920 | END | |
42921 | ||
42922 | <STATIC> | |
42923 | ||
42924 | import from TempA all; | |
42925 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
42926 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
42927 | ||
42928 | const BERPDU myValue := {true, false } | |
42929 | ||
42930 | <TTCN_TC:EXEC> | |
42931 | ||
42932 | ||
42933 | ||
42934 | ||
42935 | if ((enc_DER_PDU(myValue) == 'A00831060101000101FF'O)and(enc_CER_PDU(myValue) == 'A08031800101000101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
42936 | ||
42937 | <RESULT> | |
42938 | ||
42939 | Overall verdict: pass | |
42940 | ||
42941 | <END_TC> | |
42942 | ||
42943 | :exmp. | |
42944 | ||
42945 | .*---------------------------------------------------------------------* | |
42946 | :h3.CER + DER encoding of TAGGED SET OF BOOLEAN, EXPLICIT TAGGING | |
42947 | .*---------------------------------------------------------------------* | |
42948 | :xmp tab=0. | |
42949 | ||
42950 | <TC - CER + DER encoding of TAGGED SET OF BOOLEAN, EXPLICIT TAGGING> | |
42951 | ||
42952 | <STATIC:ASN> | |
42953 | ||
42954 | TempA | |
42955 | ||
42956 | DEFINITIONS | |
42957 | ||
42958 | EXPLICIT TAGS | |
42959 | ||
42960 | ::= | |
42961 | ||
42962 | BEGIN | |
42963 | ||
42964 | BERPDU ::= [0] SET OF BOOLEAN | |
42965 | ||
42966 | ||
42967 | ||
42968 | END | |
42969 | ||
42970 | <STATIC> | |
42971 | ||
42972 | import from TempA all; | |
42973 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
42974 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
42975 | ||
42976 | const BERPDU myValue := {true, false } | |
42977 | ||
42978 | <TTCN_TC:EXEC> | |
42979 | ||
42980 | ||
42981 | ||
42982 | ||
42983 | if ((enc_DER_PDU(myValue) == 'A00831060101000101FF'O)and(enc_CER_PDU(myValue) == 'A08031800101000101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
42984 | ||
42985 | <RESULT> | |
42986 | ||
42987 | Overall verdict: pass | |
42988 | ||
42989 | <END_TC> | |
42990 | ||
42991 | :exmp. | |
42992 | ||
42993 | .*---------------------------------------------------------------------* | |
42994 | :h3.CER + DER encoding of TAGGED SET OF BOOLEAN, IMPLICIT TAGGING | |
42995 | .*---------------------------------------------------------------------* | |
42996 | :xmp tab=0. | |
42997 | ||
42998 | <TC - CER + DER encoding of TAGGED SET OF BOOLEAN, IMPLICIT TAGGING> | |
42999 | ||
43000 | <STATIC:ASN> | |
43001 | ||
43002 | TempA | |
43003 | ||
43004 | DEFINITIONS | |
43005 | ||
43006 | IMPLICIT TAGS | |
43007 | ||
43008 | ::= | |
43009 | ||
43010 | BEGIN | |
43011 | ||
43012 | BERPDU ::= [0] SET OF BOOLEAN | |
43013 | ||
43014 | ||
43015 | ||
43016 | END | |
43017 | ||
43018 | <STATIC> | |
43019 | ||
43020 | import from TempA all; | |
43021 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
43022 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
43023 | ||
43024 | const BERPDU myValue := {true, false } | |
43025 | ||
43026 | <TTCN_TC:EXEC> | |
43027 | ||
43028 | ||
43029 | ||
43030 | ||
43031 | if ((enc_DER_PDU(myValue) == 'A0060101000101FF'O)and(enc_CER_PDU(myValue) == 'A0800101000101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
43032 | ||
43033 | <RESULT> | |
43034 | ||
43035 | Overall verdict: pass | |
43036 | ||
43037 | <END_TC> | |
43038 | ||
43039 | :exmp. | |
43040 | ||
43041 | .*---------------------------------------------------------------------* | |
43042 | :h3.CER + DER encoding of SET OF OCTET STRING | |
43043 | .*---------------------------------------------------------------------* | |
43044 | :xmp tab=0. | |
43045 | ||
43046 | <TC - CER + DER encoding of SET OF OCTET STRING > | |
43047 | ||
43048 | <STATIC:ASN> | |
43049 | ||
43050 | TempA | |
43051 | ||
43052 | DEFINITIONS ::= | |
43053 | BEGIN | |
43054 | ||
43055 | BERPDU ::= SET OF OCTET STRING | |
43056 | ||
43057 | END | |
43058 | ||
43059 | <STATIC> | |
43060 | ||
43061 | import from TempA all; | |
43062 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
43063 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
43064 | ||
43065 | const BERPDU myValue := {'FFFF'O, ''O }; | |
43066 | ||
43067 | <TTCN_TC:EXEC> | |
43068 | ||
43069 | if ((enc_DER_PDU(myValue) == '310604000402FFFF'O)and(enc_CER_PDU(myValue) == '318004000402FFFF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
43070 | ||
43071 | <RESULT> | |
43072 | ||
43073 | Overall verdict: pass | |
43074 | ||
43075 | <END_TC> | |
43076 | ||
43077 | :exmp. | |
43078 | ||
43079 | .*---------------------------------------------------------------------* | |
43080 | :h3. DECODING DER, SET OF INTEGER (empty) | |
43081 | .*---------------------------------------------------------------------* | |
43082 | :xmp tab=0. | |
43083 | ||
43084 | <TC - DECODING DER, SET OF INTEGER (empty)> | |
43085 | ||
43086 | <STATIC:ASN> | |
43087 | ||
43088 | TempA | |
43089 | ||
43090 | DEFINITIONS ::= | |
43091 | BEGIN | |
43092 | ||
43093 | BERPDU ::= SET OF INTEGER | |
43094 | ||
43095 | END | |
43096 | ||
43097 | <STATIC> | |
43098 | ||
43099 | import from TempA all; | |
43100 | ||
43101 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43102 | ||
43103 | const BERPDU myValue := { } | |
43104 | ||
43105 | ||
43106 | <TTCN_TC:EXEC> | |
43107 | ||
43108 | if (dec_BER_PDU('3100'O) == myValue) | |
43109 | ||
43110 | {setverdict(pass);} else {setverdict(fail);} | |
43111 | ||
43112 | ||
43113 | <RESULT> | |
43114 | ||
43115 | Overall verdict: pass | |
43116 | ||
43117 | <END_TC> | |
43118 | ||
43119 | :exmp. | |
43120 | ||
43121 | .*---------------------------------------------------------------------* | |
43122 | :h3. DECODING CER, SET OF INTEGER (empty) | |
43123 | .*---------------------------------------------------------------------* | |
43124 | :xmp tab=0. | |
43125 | ||
43126 | <TC - DECODING CER, SET OF INTEGER (empty)> | |
43127 | ||
43128 | <STATIC:ASN> | |
43129 | ||
43130 | TempA | |
43131 | ||
43132 | DEFINITIONS ::= | |
43133 | BEGIN | |
43134 | ||
43135 | BERPDU ::= SET OF INTEGER | |
43136 | ||
43137 | END | |
43138 | ||
43139 | <STATIC> | |
43140 | ||
43141 | import from TempA all; | |
43142 | ||
43143 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43144 | ||
43145 | const BERPDU myValue := { } | |
43146 | ||
43147 | ||
43148 | <TTCN_TC:EXEC> | |
43149 | ||
43150 | if (dec_BER_PDU('31800000'O) == myValue) | |
43151 | ||
43152 | {setverdict(pass);} else {setverdict(fail);} | |
43153 | ||
43154 | ||
43155 | <RESULT> | |
43156 | ||
43157 | Overall verdict: pass | |
43158 | ||
43159 | <END_TC> | |
43160 | ||
43161 | :exmp. | |
43162 | ||
43163 | .*---------------------------------------------------------------------* | |
43164 | :h3. DECODING DER, SET OF BOOLEAN | |
43165 | .*---------------------------------------------------------------------* | |
43166 | :xmp tab=0. | |
43167 | ||
43168 | <TC - DECODING DER, SET OF BOOLEAN> | |
43169 | ||
43170 | <STATIC:ASN> | |
43171 | ||
43172 | TempA | |
43173 | ||
43174 | DEFINITIONS ::= | |
43175 | BEGIN | |
43176 | ||
43177 | BERPDU ::= SET OF BOOLEAN | |
43178 | ||
43179 | END | |
43180 | ||
43181 | <STATIC> | |
43182 | ||
43183 | import from TempA all; | |
43184 | ||
43185 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43186 | ||
43187 | const BERPDU myValue := {true, false } | |
43188 | ||
43189 | ||
43190 | <TTCN_TC:EXEC> | |
43191 | ||
43192 | if (dec_BER_PDU('31060101000101FF'O) == myValue) | |
43193 | ||
43194 | {setverdict(pass);} else {setverdict(fail);} | |
43195 | ||
43196 | ||
43197 | <RESULT> | |
43198 | ||
43199 | Overall verdict: pass | |
43200 | ||
43201 | <END_TC> | |
43202 | ||
43203 | :exmp. | |
43204 | ||
43205 | .*---------------------------------------------------------------------* | |
43206 | :h3. DECODING CER, SET OF BOOLEAN | |
43207 | .*---------------------------------------------------------------------* | |
43208 | :xmp tab=0. | |
43209 | ||
43210 | <TC - DECODING CER, SET OF BOOLEAN> | |
43211 | ||
43212 | <STATIC:ASN> | |
43213 | ||
43214 | TempA | |
43215 | ||
43216 | DEFINITIONS ::= | |
43217 | BEGIN | |
43218 | ||
43219 | BERPDU ::= SET OF BOOLEAN | |
43220 | ||
43221 | END | |
43222 | ||
43223 | <STATIC> | |
43224 | ||
43225 | import from TempA all; | |
43226 | ||
43227 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43228 | ||
43229 | const BERPDU myValue := {true, false } | |
43230 | ||
43231 | ||
43232 | <TTCN_TC:EXEC> | |
43233 | ||
43234 | if (dec_BER_PDU('31800101000101FF0000'O) == myValue) | |
43235 | ||
43236 | {setverdict(pass);} else {setverdict(fail);} | |
43237 | ||
43238 | ||
43239 | <RESULT> | |
43240 | ||
43241 | Overall verdict: pass | |
43242 | ||
43243 | <END_TC> | |
43244 | ||
43245 | :exmp. | |
43246 | ||
43247 | .*---------------------------------------------------------------------* | |
43248 | :h3. DECODING , SET OF BOOLEAN (different order) | |
43249 | .*---------------------------------------------------------------------* | |
43250 | :xmp tab=0. | |
43251 | ||
43252 | <TC - DECODING , SET OF BOOLEAN (different order)> | |
43253 | ||
43254 | <STATIC:ASN> | |
43255 | ||
43256 | TempA | |
43257 | ||
43258 | DEFINITIONS ::= | |
43259 | BEGIN | |
43260 | ||
43261 | BERPDU ::= SET OF BOOLEAN | |
43262 | ||
43263 | END | |
43264 | ||
43265 | <STATIC> | |
43266 | ||
43267 | import from TempA all; | |
43268 | ||
43269 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43270 | ||
43271 | const BERPDU myValue := {true, false } | |
43272 | ||
43273 | ||
43274 | <TTCN_TC:EXEC> | |
43275 | ||
43276 | if (dec_BER_PDU('31060101FF010100'O) == myValue) | |
43277 | ||
43278 | {setverdict(pass);} else {setverdict(fail);} | |
43279 | ||
43280 | ||
43281 | <RESULT> | |
43282 | ||
43283 | Overall verdict: pass | |
43284 | ||
43285 | <END_TC> | |
43286 | ||
43287 | :exmp. | |
43288 | ||
43289 | .*---------------------------------------------------------------------* | |
43290 | :h3. DECODING , SET OF BOOLEAN (different order2) | |
43291 | .*---------------------------------------------------------------------* | |
43292 | :xmp tab=0. | |
43293 | ||
43294 | <TC - DECODING , SET OF BOOLEAN (different order2)> | |
43295 | ||
43296 | <STATIC:ASN> | |
43297 | ||
43298 | TempA | |
43299 | ||
43300 | DEFINITIONS ::= | |
43301 | BEGIN | |
43302 | ||
43303 | BERPDU ::= SET OF BOOLEAN | |
43304 | ||
43305 | END | |
43306 | ||
43307 | <STATIC> | |
43308 | ||
43309 | import from TempA all; | |
43310 | ||
43311 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43312 | ||
43313 | const BERPDU myValue := {true, false } | |
43314 | ||
43315 | ||
43316 | <TTCN_TC:EXEC> | |
43317 | ||
43318 | if (dec_BER_PDU('31800101FF0101000000'O) == myValue) | |
43319 | ||
43320 | {setverdict(pass);} else {setverdict(fail);} | |
43321 | ||
43322 | ||
43323 | <RESULT> | |
43324 | ||
43325 | Overall verdict: pass | |
43326 | ||
43327 | <END_TC> | |
43328 | ||
43329 | :exmp. | |
43330 | ||
43331 | .*---------------------------------------------------------------------* | |
43332 | :h3. DECODING DER,SET OF OCTET STRING | |
43333 | .*---------------------------------------------------------------------* | |
43334 | :xmp tab=0. | |
43335 | ||
43336 | <TC - DECODING DER,SET OF OCTET STRING > | |
43337 | ||
43338 | <STATIC:ASN> | |
43339 | ||
43340 | TempA | |
43341 | ||
43342 | DEFINITIONS ::= | |
43343 | BEGIN | |
43344 | ||
43345 | BERPDU ::= SET OF OCTET STRING | |
43346 | ||
43347 | END | |
43348 | ||
43349 | <STATIC> | |
43350 | ||
43351 | import from TempA all; | |
43352 | ||
43353 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43354 | ||
43355 | const BERPDU myValue := {'FFFF'O, 'AB'O }; | |
43356 | ||
43357 | ||
43358 | <TTCN_TC:EXEC> | |
43359 | ||
43360 | if (dec_BER_PDU('31070401AB0402FFFF'O) == myValue) | |
43361 | ||
43362 | {setverdict(pass);} else {setverdict(fail);} | |
43363 | ||
43364 | ||
43365 | <RESULT> | |
43366 | ||
43367 | Overall verdict: pass | |
43368 | ||
43369 | <END_TC> | |
43370 | ||
43371 | :exmp. | |
43372 | ||
43373 | .*---------------------------------------------------------------------* | |
43374 | :h3. DECODING CER,SET OF OCTET STRING | |
43375 | .*---------------------------------------------------------------------* | |
43376 | :xmp tab=0. | |
43377 | ||
43378 | <TC - DECODING CER,SET OF OCTET STRING > | |
43379 | ||
43380 | <STATIC:ASN> | |
43381 | ||
43382 | TempA | |
43383 | ||
43384 | DEFINITIONS ::= | |
43385 | BEGIN | |
43386 | ||
43387 | BERPDU ::= SET OF OCTET STRING | |
43388 | ||
43389 | END | |
43390 | ||
43391 | <STATIC> | |
43392 | ||
43393 | import from TempA all; | |
43394 | ||
43395 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43396 | ||
43397 | const BERPDU myValue := {'FFFF'O, 'AB'O }; | |
43398 | ||
43399 | ||
43400 | <TTCN_TC:EXEC> | |
43401 | ||
43402 | if (dec_BER_PDU('31800401AB0402FFFF0000'O) == myValue) | |
43403 | ||
43404 | {setverdict(pass);} else {setverdict(fail);} | |
43405 | ||
43406 | ||
43407 | <RESULT> | |
43408 | ||
43409 | Overall verdict: pass | |
43410 | ||
43411 | <END_TC> | |
43412 | ||
43413 | :exmp. | |
43414 | ||
43415 | .*---------------------------------------------------------------------* | |
43416 | :h3. DECODING ,SET OF OCTET STRING (different order) | |
43417 | .*---------------------------------------------------------------------* | |
43418 | :xmp tab=0. | |
43419 | ||
43420 | <TC - DECODING ,SET OF OCTET STRING (different order)> | |
43421 | ||
43422 | <STATIC:ASN> | |
43423 | ||
43424 | TempA | |
43425 | ||
43426 | DEFINITIONS ::= | |
43427 | BEGIN | |
43428 | ||
43429 | BERPDU ::= SET OF OCTET STRING | |
43430 | ||
43431 | END | |
43432 | ||
43433 | <STATIC> | |
43434 | ||
43435 | import from TempA all; | |
43436 | ||
43437 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43438 | ||
43439 | const BERPDU myValue := {'FFFF'O, 'AB'O }; | |
43440 | ||
43441 | ||
43442 | <TTCN_TC:EXEC> | |
43443 | ||
43444 | if (dec_BER_PDU('31070402FFFF0401AB'O) == myValue) | |
43445 | ||
43446 | {setverdict(pass);} else {setverdict(fail);} | |
43447 | ||
43448 | ||
43449 | <RESULT> | |
43450 | ||
43451 | Overall verdict: pass | |
43452 | ||
43453 | <END_TC> | |
43454 | ||
43455 | :exmp. | |
43456 | ||
43457 | .*---------------------------------------------------------------------* | |
43458 | :h3. DECODING ,SET OF OCTET STRING (different order) | |
43459 | .*---------------------------------------------------------------------* | |
43460 | :xmp tab=0. | |
43461 | ||
43462 | <TC - DECODING ,SET OF OCTET STRING (different order)> | |
43463 | ||
43464 | <STATIC:ASN> | |
43465 | ||
43466 | TempA | |
43467 | ||
43468 | DEFINITIONS ::= | |
43469 | BEGIN | |
43470 | ||
43471 | BERPDU ::= SET OF OCTET STRING | |
43472 | ||
43473 | END | |
43474 | ||
43475 | <STATIC> | |
43476 | ||
43477 | import from TempA all; | |
43478 | ||
43479 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43480 | ||
43481 | const BERPDU myValue := {'FFFF'O, 'AB'O }; | |
43482 | ||
43483 | ||
43484 | <TTCN_TC:EXEC> | |
43485 | ||
43486 | if (dec_BER_PDU('31800402FFFF0401AB0000'O) == myValue) | |
43487 | ||
43488 | {setverdict(pass);} else {setverdict(fail);} | |
43489 | ||
43490 | ||
43491 | <RESULT> | |
43492 | ||
43493 | Overall verdict: pass | |
43494 | ||
43495 | <END_TC> | |
43496 | ||
43497 | :exmp. | |
43498 | ||
43499 | .*---------------------------------------------------------------------* | |
43500 | :h3. DECODING DER,SET OF SEQUENCE | |
43501 | .*---------------------------------------------------------------------* | |
43502 | :xmp tab=0. | |
43503 | ||
43504 | <TC - DECODING DER,SET OF SEQUENCE > | |
43505 | ||
43506 | <STATIC:ASN> | |
43507 | ||
43508 | TempA | |
43509 | ||
43510 | DEFINITIONS ::= | |
43511 | BEGIN | |
43512 | ||
43513 | BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN} | |
43514 | ||
43515 | END | |
43516 | ||
43517 | <STATIC> | |
43518 | ||
43519 | import from TempA all; | |
43520 | ||
43521 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43522 | ||
43523 | const BERPDU myValue := { | |
43524 | { | |
43525 | a := 5, | |
43526 | b := true | |
43527 | }, | |
43528 | ||
43529 | { | |
43530 | a := 3, | |
43531 | b := false | |
43532 | } | |
43533 | ||
43534 | }; | |
43535 | ||
43536 | ||
43537 | <TTCN_TC:EXEC> | |
43538 | ||
43539 | if (dec_BER_PDU('3110300602010301010030060201050101FF'O) == myValue) | |
43540 | ||
43541 | {setverdict(pass);} else {setverdict(fail);} | |
43542 | ||
43543 | ||
43544 | <RESULT> | |
43545 | ||
43546 | Overall verdict: pass | |
43547 | ||
43548 | <END_TC> | |
43549 | ||
43550 | :exmp. | |
43551 | ||
43552 | .*---------------------------------------------------------------------* | |
43553 | :h3. DECODING CER,SET OF SEQUENCE | |
43554 | .*---------------------------------------------------------------------* | |
43555 | :xmp tab=0. | |
43556 | ||
43557 | <TC - DECODING CER,SET OF SEQUENCE > | |
43558 | ||
43559 | <STATIC:ASN> | |
43560 | ||
43561 | TempA | |
43562 | ||
43563 | DEFINITIONS ::= | |
43564 | BEGIN | |
43565 | ||
43566 | BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN} | |
43567 | ||
43568 | END | |
43569 | ||
43570 | <STATIC> | |
43571 | ||
43572 | import from TempA all; | |
43573 | ||
43574 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43575 | ||
43576 | const BERPDU myValue := { | |
43577 | { | |
43578 | a := 5, | |
43579 | b := true | |
43580 | }, | |
43581 | ||
43582 | { | |
43583 | a := 3, | |
43584 | b := false | |
43585 | } | |
43586 | ||
43587 | }; | |
43588 | ||
43589 | ||
43590 | <TTCN_TC:EXEC> | |
43591 | ||
43592 | if (dec_BER_PDU('31803080020103010100000030800201050101FF00000000'O) == myValue) | |
43593 | ||
43594 | {setverdict(pass);} else {setverdict(fail);} | |
43595 | ||
43596 | ||
43597 | <RESULT> | |
43598 | ||
43599 | Overall verdict: pass | |
43600 | ||
43601 | <END_TC> | |
43602 | ||
43603 | :exmp. | |
43604 | ||
43605 | .*---------------------------------------------------------------------* | |
43606 | :h3. DECODING ,SET OF SEQUENCE (different order) | |
43607 | .*---------------------------------------------------------------------* | |
43608 | :xmp tab=0. | |
43609 | ||
43610 | <TC - DECODING ,SET OF SEQUENCE (different order)> | |
43611 | ||
43612 | <STATIC:ASN> | |
43613 | ||
43614 | TempA | |
43615 | ||
43616 | DEFINITIONS ::= | |
43617 | BEGIN | |
43618 | ||
43619 | BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN} | |
43620 | ||
43621 | END | |
43622 | ||
43623 | <STATIC> | |
43624 | ||
43625 | import from TempA all; | |
43626 | ||
43627 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43628 | ||
43629 | const BERPDU myValue := { | |
43630 | { | |
43631 | a := 5, | |
43632 | b := true | |
43633 | }, | |
43634 | ||
43635 | { | |
43636 | a := 3, | |
43637 | b := false | |
43638 | } | |
43639 | ||
43640 | }; | |
43641 | ||
43642 | ||
43643 | <TTCN_TC:EXEC> | |
43644 | ||
43645 | if (dec_BER_PDU('311030060201050101FF3006020103010100'O) == myValue) | |
43646 | ||
43647 | {setverdict(pass);} else {setverdict(fail);} | |
43648 | ||
43649 | ||
43650 | <RESULT> | |
43651 | ||
43652 | Overall verdict: pass | |
43653 | ||
43654 | <END_TC> | |
43655 | ||
43656 | :exmp. | |
43657 | ||
43658 | .*---------------------------------------------------------------------* | |
43659 | :h3. DECODING ,SET OF SEQUENCE (different order2) | |
43660 | .*---------------------------------------------------------------------* | |
43661 | :xmp tab=0. | |
43662 | ||
43663 | <TC - DECODING ,SET OF SEQUENCE (different order2)> | |
43664 | ||
43665 | <STATIC:ASN> | |
43666 | ||
43667 | TempA | |
43668 | ||
43669 | DEFINITIONS ::= | |
43670 | BEGIN | |
43671 | ||
43672 | BERPDU ::= SET OF SEQUENCE {a INTEGER, b BOOLEAN} | |
43673 | ||
43674 | END | |
43675 | ||
43676 | <STATIC> | |
43677 | ||
43678 | import from TempA all; | |
43679 | ||
43680 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43681 | ||
43682 | const BERPDU myValue := { | |
43683 | { | |
43684 | a := 5, | |
43685 | b := true | |
43686 | }, | |
43687 | ||
43688 | { | |
43689 | a := 3, | |
43690 | b := false | |
43691 | } | |
43692 | ||
43693 | }; | |
43694 | ||
43695 | ||
43696 | <TTCN_TC:EXEC> | |
43697 | ||
43698 | if (dec_BER_PDU('318030800201050101FF0000308002010301010000000000'O) == myValue) | |
43699 | ||
43700 | {setverdict(pass);} else {setverdict(fail);} | |
43701 | ||
43702 | ||
43703 | <RESULT> | |
43704 | ||
43705 | Overall verdict: pass | |
43706 | ||
43707 | <END_TC> | |
43708 | ||
43709 | :exmp. | |
43710 | ||
43711 | .*---------------------------------------------------------------------* | |
43712 | :h3. DECODING DER,SET OF SET | |
43713 | .*---------------------------------------------------------------------* | |
43714 | :xmp tab=0. | |
43715 | ||
43716 | <TC - DECODING DER,SET OF SET > | |
43717 | ||
43718 | <STATIC:ASN> | |
43719 | ||
43720 | TempA | |
43721 | ||
43722 | DEFINITIONS ::= | |
43723 | BEGIN | |
43724 | ||
43725 | BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN} | |
43726 | ||
43727 | END | |
43728 | ||
43729 | <STATIC> | |
43730 | ||
43731 | import from TempA all; | |
43732 | ||
43733 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43734 | ||
43735 | const BERPDU myValue := { | |
43736 | { | |
43737 | a := 5, | |
43738 | b := true | |
43739 | }, | |
43740 | ||
43741 | { | |
43742 | a := 3, | |
43743 | b := false | |
43744 | } | |
43745 | ||
43746 | }; | |
43747 | ||
43748 | ||
43749 | <TTCN_TC:EXEC> | |
43750 | ||
43751 | if (dec_BER_PDU('3110310601010002010331060101FF020105'O) == myValue) | |
43752 | ||
43753 | {setverdict(pass);} else {setverdict(fail);} | |
43754 | ||
43755 | ||
43756 | <RESULT> | |
43757 | ||
43758 | Overall verdict: pass | |
43759 | ||
43760 | <END_TC> | |
43761 | ||
43762 | :exmp. | |
43763 | ||
43764 | .*---------------------------------------------------------------------* | |
43765 | :h3. DECODING CER,SET OF SET | |
43766 | .*---------------------------------------------------------------------* | |
43767 | :xmp tab=0. | |
43768 | ||
43769 | <TC - DECODING CER,SET OF SET > | |
43770 | ||
43771 | <STATIC:ASN> | |
43772 | ||
43773 | TempA | |
43774 | ||
43775 | DEFINITIONS ::= | |
43776 | BEGIN | |
43777 | ||
43778 | BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN} | |
43779 | ||
43780 | END | |
43781 | ||
43782 | <STATIC> | |
43783 | ||
43784 | import from TempA all; | |
43785 | ||
43786 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43787 | ||
43788 | const BERPDU myValue := { | |
43789 | { | |
43790 | a := 5, | |
43791 | b := true | |
43792 | }, | |
43793 | ||
43794 | { | |
43795 | a := 3, | |
43796 | b := false | |
43797 | } | |
43798 | ||
43799 | }; | |
43800 | ||
43801 | ||
43802 | <TTCN_TC:EXEC> | |
43803 | ||
43804 | if (dec_BER_PDU('31803180010100020103000031800101FF02010500000000'O) == myValue) | |
43805 | ||
43806 | {setverdict(pass);} else {setverdict(fail);} | |
43807 | ||
43808 | ||
43809 | <RESULT> | |
43810 | ||
43811 | Overall verdict: pass | |
43812 | ||
43813 | <END_TC> | |
43814 | ||
43815 | :exmp. | |
43816 | ||
43817 | .*---------------------------------------------------------------------* | |
43818 | :h3. DECODING ,SET OF SET (different order) | |
43819 | .*---------------------------------------------------------------------* | |
43820 | :xmp tab=0. | |
43821 | ||
43822 | <TC - DECODING ,SET OF SET (different order)> | |
43823 | ||
43824 | <STATIC:ASN> | |
43825 | ||
43826 | TempA | |
43827 | ||
43828 | DEFINITIONS ::= | |
43829 | BEGIN | |
43830 | ||
43831 | BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN} | |
43832 | ||
43833 | END | |
43834 | ||
43835 | <STATIC> | |
43836 | ||
43837 | import from TempA all; | |
43838 | ||
43839 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43840 | ||
43841 | const BERPDU myValue := { | |
43842 | { | |
43843 | a := 5, | |
43844 | b := true | |
43845 | }, | |
43846 | ||
43847 | { | |
43848 | a := 3, | |
43849 | b := false | |
43850 | } | |
43851 | ||
43852 | }; | |
43853 | ||
43854 | ||
43855 | <TTCN_TC:EXEC> | |
43856 | ||
43857 | if (dec_BER_PDU('311031060101FF0201053106010100020103'O) == myValue) | |
43858 | ||
43859 | {setverdict(pass);} else {setverdict(fail);} | |
43860 | ||
43861 | ||
43862 | <RESULT> | |
43863 | ||
43864 | Overall verdict: pass | |
43865 | ||
43866 | <END_TC> | |
43867 | ||
43868 | :exmp. | |
43869 | ||
43870 | .*---------------------------------------------------------------------* | |
43871 | :h3. DECODING ,SET OF SET (different order2) | |
43872 | .*---------------------------------------------------------------------* | |
43873 | :xmp tab=0. | |
43874 | ||
43875 | <TC - DECODING ,SET OF SET (different order2)> | |
43876 | ||
43877 | <STATIC:ASN> | |
43878 | ||
43879 | TempA | |
43880 | ||
43881 | DEFINITIONS ::= | |
43882 | BEGIN | |
43883 | ||
43884 | BERPDU ::= SET OF SET {a INTEGER, b BOOLEAN} | |
43885 | ||
43886 | END | |
43887 | ||
43888 | <STATIC> | |
43889 | ||
43890 | import from TempA all; | |
43891 | ||
43892 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43893 | ||
43894 | const BERPDU myValue := { | |
43895 | { | |
43896 | a := 5, | |
43897 | b := true | |
43898 | }, | |
43899 | ||
43900 | { | |
43901 | a := 3, | |
43902 | b := false | |
43903 | } | |
43904 | ||
43905 | }; | |
43906 | ||
43907 | ||
43908 | <TTCN_TC:EXEC> | |
43909 | ||
43910 | if (dec_BER_PDU('318031800101FF0201050000318001010002010300000000'O) == myValue) | |
43911 | ||
43912 | {setverdict(pass);} else {setverdict(fail);} | |
43913 | ||
43914 | ||
43915 | <RESULT> | |
43916 | ||
43917 | Overall verdict: pass | |
43918 | ||
43919 | <END_TC> | |
43920 | ||
43921 | :exmp. | |
43922 | ||
43923 | .*---------------------------------------------------------------------* | |
43924 | :h3. DECODING DER,SET OF CHOICE | |
43925 | .*---------------------------------------------------------------------* | |
43926 | :xmp tab=0. | |
43927 | ||
43928 | <TC - DECODING DER,SET OF CHOICE > | |
43929 | ||
43930 | <STATIC:ASN> | |
43931 | ||
43932 | TempA | |
43933 | ||
43934 | DEFINITIONS ::= | |
43935 | BEGIN | |
43936 | ||
43937 | BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN} | |
43938 | ||
43939 | END | |
43940 | ||
43941 | <STATIC> | |
43942 | ||
43943 | import from TempA all; | |
43944 | ||
43945 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43946 | ||
43947 | const BERPDU myValue := { | |
43948 | { | |
43949 | a := 5 | |
43950 | }, | |
43951 | ||
43952 | { | |
43953 | b := false | |
43954 | } | |
43955 | ||
43956 | }; | |
43957 | ||
43958 | ||
43959 | <TTCN_TC:EXEC> | |
43960 | ||
43961 | if (dec_BER_PDU('3106010100020105'O) == myValue) | |
43962 | ||
43963 | {setverdict(pass);} else {setverdict(fail);} | |
43964 | ||
43965 | ||
43966 | <RESULT> | |
43967 | ||
43968 | Overall verdict: pass | |
43969 | ||
43970 | <END_TC> | |
43971 | ||
43972 | :exmp. | |
43973 | ||
43974 | .*---------------------------------------------------------------------* | |
43975 | :h3. DECODING CER,SET OF CHOICE | |
43976 | .*---------------------------------------------------------------------* | |
43977 | :xmp tab=0. | |
43978 | ||
43979 | <TC - DECODING CER,SET OF CHOICE > | |
43980 | ||
43981 | <STATIC:ASN> | |
43982 | ||
43983 | TempA | |
43984 | ||
43985 | DEFINITIONS ::= | |
43986 | BEGIN | |
43987 | ||
43988 | BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN} | |
43989 | ||
43990 | END | |
43991 | ||
43992 | <STATIC> | |
43993 | ||
43994 | import from TempA all; | |
43995 | ||
43996 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
43997 | ||
43998 | const BERPDU myValue := { | |
43999 | { | |
44000 | a := 5 | |
44001 | }, | |
44002 | ||
44003 | { | |
44004 | b := false | |
44005 | } | |
44006 | ||
44007 | }; | |
44008 | ||
44009 | ||
44010 | <TTCN_TC:EXEC> | |
44011 | ||
44012 | if (dec_BER_PDU('31800101000201050000'O) == myValue) | |
44013 | ||
44014 | {setverdict(pass);} else {setverdict(fail);} | |
44015 | ||
44016 | ||
44017 | <RESULT> | |
44018 | ||
44019 | Overall verdict: pass | |
44020 | ||
44021 | <END_TC> | |
44022 | ||
44023 | :exmp. | |
44024 | ||
44025 | .*---------------------------------------------------------------------* | |
44026 | :h3. DECODING ,SET OF CHOICE (different order) | |
44027 | .*---------------------------------------------------------------------* | |
44028 | :xmp tab=0. | |
44029 | ||
44030 | <TC - DECODING ,SET OF CHOICE (different order)> | |
44031 | ||
44032 | <STATIC:ASN> | |
44033 | ||
44034 | TempA | |
44035 | ||
44036 | DEFINITIONS ::= | |
44037 | BEGIN | |
44038 | ||
44039 | BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN} | |
44040 | ||
44041 | END | |
44042 | ||
44043 | <STATIC> | |
44044 | ||
44045 | import from TempA all; | |
44046 | ||
44047 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44048 | ||
44049 | const BERPDU myValue := { | |
44050 | { | |
44051 | a := 5 | |
44052 | }, | |
44053 | ||
44054 | { | |
44055 | b := false | |
44056 | } | |
44057 | ||
44058 | }; | |
44059 | ||
44060 | ||
44061 | <TTCN_TC:EXEC> | |
44062 | ||
44063 | if (dec_BER_PDU('3106020105010100'O) == myValue) | |
44064 | ||
44065 | {setverdict(pass);} else {setverdict(fail);} | |
44066 | ||
44067 | ||
44068 | <RESULT> | |
44069 | ||
44070 | Overall verdict: pass | |
44071 | ||
44072 | <END_TC> | |
44073 | ||
44074 | :exmp. | |
44075 | ||
44076 | .*---------------------------------------------------------------------* | |
44077 | :h3. DECODING ,SET OF CHOICE (different order2) | |
44078 | .*---------------------------------------------------------------------* | |
44079 | :xmp tab=0. | |
44080 | ||
44081 | <TC - DECODING ,SET OF CHOICE (different order2)> | |
44082 | ||
44083 | <STATIC:ASN> | |
44084 | ||
44085 | TempA | |
44086 | ||
44087 | DEFINITIONS ::= | |
44088 | BEGIN | |
44089 | ||
44090 | BERPDU ::= SET OF CHOICE{a INTEGER, b BOOLEAN} | |
44091 | ||
44092 | END | |
44093 | ||
44094 | <STATIC> | |
44095 | ||
44096 | import from TempA all; | |
44097 | ||
44098 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44099 | ||
44100 | const BERPDU myValue := { | |
44101 | { | |
44102 | a := 5 | |
44103 | }, | |
44104 | ||
44105 | { | |
44106 | b := false | |
44107 | } | |
44108 | ||
44109 | }; | |
44110 | ||
44111 | ||
44112 | <TTCN_TC:EXEC> | |
44113 | ||
44114 | if (dec_BER_PDU('31800201050101000000'O) == myValue) | |
44115 | ||
44116 | {setverdict(pass);} else {setverdict(fail);} | |
44117 | ||
44118 | ||
44119 | <RESULT> | |
44120 | ||
44121 | Overall verdict: pass | |
44122 | ||
44123 | <END_TC> | |
44124 | ||
44125 | :exmp. | |
44126 | ||
44127 | .*---------------------------------------------------------------------* | |
44128 | :h3. DECODING DER,SET OF SEQUENCE OF | |
44129 | .*---------------------------------------------------------------------* | |
44130 | :xmp tab=0. | |
44131 | ||
44132 | <TC - DECODING DER,SET OF SEQUENCE OF> | |
44133 | ||
44134 | <STATIC:ASN> | |
44135 | ||
44136 | TempA | |
44137 | ||
44138 | DEFINITIONS ::= | |
44139 | BEGIN | |
44140 | ||
44141 | BERPDU ::= SET OF SEQUENCE OF INTEGER | |
44142 | ||
44143 | END | |
44144 | ||
44145 | <STATIC> | |
44146 | ||
44147 | import from TempA all; | |
44148 | ||
44149 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44150 | ||
44151 | const BERPDU myValue := { | |
44152 | { | |
44153 | 5, | |
44154 | 6, | |
44155 | 7 | |
44156 | }, | |
44157 | ||
44158 | { | |
44159 | 1, | |
44160 | 2, | |
44161 | 3 | |
44162 | } | |
44163 | }; | |
44164 | ||
44165 | ||
44166 | <TTCN_TC:EXEC> | |
44167 | ||
44168 | if (dec_BER_PDU('311630090201010201020201033009020105020106020107'O) == myValue) | |
44169 | ||
44170 | {setverdict(pass);} else {setverdict(fail);} | |
44171 | ||
44172 | ||
44173 | <RESULT> | |
44174 | ||
44175 | Overall verdict: pass | |
44176 | ||
44177 | <END_TC> | |
44178 | ||
44179 | :exmp. | |
44180 | ||
44181 | .*---------------------------------------------------------------------* | |
44182 | :h3. DECODING CER,SET OF SEQUENCE OF | |
44183 | .*---------------------------------------------------------------------* | |
44184 | :xmp tab=0. | |
44185 | ||
44186 | <TC - DECODING CER,SET OF SEQUENCE OF> | |
44187 | ||
44188 | <STATIC:ASN> | |
44189 | ||
44190 | TempA | |
44191 | ||
44192 | DEFINITIONS ::= | |
44193 | BEGIN | |
44194 | ||
44195 | BERPDU ::= SET OF SEQUENCE OF INTEGER | |
44196 | ||
44197 | END | |
44198 | ||
44199 | <STATIC> | |
44200 | ||
44201 | import from TempA all; | |
44202 | ||
44203 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44204 | ||
44205 | const BERPDU myValue := { | |
44206 | { | |
44207 | 5, | |
44208 | 6, | |
44209 | 7 | |
44210 | }, | |
44211 | ||
44212 | { | |
44213 | 1, | |
44214 | 2, | |
44215 | 3 | |
44216 | } | |
44217 | }; | |
44218 | ||
44219 | ||
44220 | <TTCN_TC:EXEC> | |
44221 | ||
44222 | if (dec_BER_PDU('318030800201010201020201030000308002010502010602010700000000'O) == myValue) | |
44223 | ||
44224 | {setverdict(pass);} else {setverdict(fail);} | |
44225 | ||
44226 | ||
44227 | <RESULT> | |
44228 | ||
44229 | Overall verdict: pass | |
44230 | ||
44231 | <END_TC> | |
44232 | ||
44233 | :exmp. | |
44234 | ||
44235 | .*---------------------------------------------------------------------* | |
44236 | :h3. DECODING ,SET OF SEQUENCE OF, (different order) | |
44237 | .*---------------------------------------------------------------------* | |
44238 | :xmp tab=0. | |
44239 | ||
44240 | <TC - DECODING ,SET OF SEQUENCE OF, (different order)> | |
44241 | ||
44242 | <STATIC:ASN> | |
44243 | ||
44244 | TempA | |
44245 | ||
44246 | DEFINITIONS ::= | |
44247 | BEGIN | |
44248 | ||
44249 | BERPDU ::= SET OF SEQUENCE OF INTEGER | |
44250 | ||
44251 | END | |
44252 | ||
44253 | <STATIC> | |
44254 | ||
44255 | import from TempA all; | |
44256 | ||
44257 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44258 | ||
44259 | const BERPDU myValue := { | |
44260 | { | |
44261 | 5, | |
44262 | 6, | |
44263 | 7 | |
44264 | }, | |
44265 | ||
44266 | { | |
44267 | 1, | |
44268 | 2, | |
44269 | 3 | |
44270 | } | |
44271 | }; | |
44272 | ||
44273 | ||
44274 | <TTCN_TC:EXEC> | |
44275 | ||
44276 | if (dec_BER_PDU('311630090201050201060201073009020101020102020103'O) == myValue) | |
44277 | ||
44278 | {setverdict(pass);} else {setverdict(fail);} | |
44279 | ||
44280 | ||
44281 | <RESULT> | |
44282 | ||
44283 | Overall verdict: pass | |
44284 | ||
44285 | <END_TC> | |
44286 | ||
44287 | :exmp. | |
44288 | ||
44289 | .*---------------------------------------------------------------------* | |
44290 | :h3. DECODING ,SET OF SEQUENCE OF, (different order2) | |
44291 | .*---------------------------------------------------------------------* | |
44292 | :xmp tab=0. | |
44293 | ||
44294 | <TC - DECODING ,SET OF SEQUENCE OF, (different order2)> | |
44295 | ||
44296 | <STATIC:ASN> | |
44297 | ||
44298 | TempA | |
44299 | ||
44300 | DEFINITIONS ::= | |
44301 | BEGIN | |
44302 | ||
44303 | BERPDU ::= SET OF SEQUENCE OF INTEGER | |
44304 | ||
44305 | END | |
44306 | ||
44307 | <STATIC> | |
44308 | ||
44309 | import from TempA all; | |
44310 | ||
44311 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44312 | ||
44313 | const BERPDU myValue := { | |
44314 | { | |
44315 | 5, | |
44316 | 6, | |
44317 | 7 | |
44318 | }, | |
44319 | ||
44320 | { | |
44321 | 1, | |
44322 | 2, | |
44323 | 3 | |
44324 | } | |
44325 | }; | |
44326 | ||
44327 | ||
44328 | <TTCN_TC:EXEC> | |
44329 | ||
44330 | if (dec_BER_PDU('318030800201050201060201070000308002010102010202010300000000'O) == myValue) | |
44331 | ||
44332 | {setverdict(pass);} else {setverdict(fail);} | |
44333 | ||
44334 | ||
44335 | <RESULT> | |
44336 | ||
44337 | Overall verdict: pass | |
44338 | ||
44339 | <END_TC> | |
44340 | ||
44341 | :exmp. | |
44342 | ||
44343 | .*---------------------------------------------------------------------* | |
44344 | :h3. DECODING DER,SET OF SET OF | |
44345 | .*---------------------------------------------------------------------* | |
44346 | :xmp tab=0. | |
44347 | ||
44348 | <TC - DECODING DER,SET OF SET OF> | |
44349 | ||
44350 | <STATIC:ASN> | |
44351 | ||
44352 | TempA | |
44353 | ||
44354 | DEFINITIONS ::= | |
44355 | BEGIN | |
44356 | ||
44357 | BERPDU ::= SET OF SET OF INTEGER | |
44358 | ||
44359 | END | |
44360 | ||
44361 | <STATIC> | |
44362 | ||
44363 | import from TempA all; | |
44364 | ||
44365 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44366 | ||
44367 | const BERPDU myValue := { | |
44368 | { | |
44369 | 5, | |
44370 | 6, | |
44371 | 7 | |
44372 | }, | |
44373 | ||
44374 | { | |
44375 | 1, | |
44376 | 2, | |
44377 | 3 | |
44378 | } | |
44379 | }; | |
44380 | ||
44381 | ||
44382 | <TTCN_TC:EXEC> | |
44383 | ||
44384 | if (dec_BER_PDU('311631090201010201020201033109020105020106020107'O) == myValue) | |
44385 | ||
44386 | {setverdict(pass);} else {setverdict(fail);} | |
44387 | ||
44388 | ||
44389 | <RESULT> | |
44390 | ||
44391 | Overall verdict: pass | |
44392 | ||
44393 | <END_TC> | |
44394 | ||
44395 | :exmp. | |
44396 | ||
44397 | .*---------------------------------------------------------------------* | |
44398 | :h3. DECODING CER,SET OF SET OF | |
44399 | .*---------------------------------------------------------------------* | |
44400 | :xmp tab=0. | |
44401 | ||
44402 | <TC - DECODING CER,SET OF SET OF> | |
44403 | ||
44404 | <STATIC:ASN> | |
44405 | ||
44406 | TempA | |
44407 | ||
44408 | DEFINITIONS ::= | |
44409 | BEGIN | |
44410 | ||
44411 | BERPDU ::= SET OF SET OF INTEGER | |
44412 | ||
44413 | END | |
44414 | ||
44415 | <STATIC> | |
44416 | ||
44417 | import from TempA all; | |
44418 | ||
44419 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44420 | ||
44421 | const BERPDU myValue := { | |
44422 | { | |
44423 | 5, | |
44424 | 6, | |
44425 | 7 | |
44426 | }, | |
44427 | ||
44428 | { | |
44429 | 1, | |
44430 | 2, | |
44431 | 3 | |
44432 | } | |
44433 | }; | |
44434 | ||
44435 | ||
44436 | <TTCN_TC:EXEC> | |
44437 | ||
44438 | if (dec_BER_PDU('318031800201010201020201030000318002010502010602010700000000'O) == myValue) | |
44439 | ||
44440 | {setverdict(pass);} else {setverdict(fail);} | |
44441 | ||
44442 | ||
44443 | <RESULT> | |
44444 | ||
44445 | Overall verdict: pass | |
44446 | ||
44447 | <END_TC> | |
44448 | ||
44449 | :exmp. | |
44450 | ||
44451 | .*---------------------------------------------------------------------* | |
44452 | :h3. DECODING ,SET OF SET OF (different order) | |
44453 | .*---------------------------------------------------------------------* | |
44454 | :xmp tab=0. | |
44455 | ||
44456 | <TC - DECODING ,SET OF SET OF (different order)> | |
44457 | ||
44458 | <STATIC:ASN> | |
44459 | ||
44460 | TempA | |
44461 | ||
44462 | DEFINITIONS ::= | |
44463 | BEGIN | |
44464 | ||
44465 | BERPDU ::= SET OF SET OF INTEGER | |
44466 | ||
44467 | END | |
44468 | ||
44469 | <STATIC> | |
44470 | ||
44471 | import from TempA all; | |
44472 | ||
44473 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44474 | ||
44475 | const BERPDU myValue := { | |
44476 | { | |
44477 | 5, | |
44478 | 6, | |
44479 | 7 | |
44480 | }, | |
44481 | ||
44482 | { | |
44483 | 1, | |
44484 | 2, | |
44485 | 3 | |
44486 | } | |
44487 | }; | |
44488 | ||
44489 | ||
44490 | <TTCN_TC:EXEC> | |
44491 | ||
44492 | if (dec_BER_PDU('311631090201050201060201073109020101020102020103'O) == myValue) | |
44493 | ||
44494 | {setverdict(pass);} else {setverdict(fail);} | |
44495 | ||
44496 | ||
44497 | <RESULT> | |
44498 | ||
44499 | Overall verdict: pass | |
44500 | ||
44501 | <END_TC> | |
44502 | ||
44503 | :exmp. | |
44504 | ||
44505 | .*---------------------------------------------------------------------* | |
44506 | :h3. DECODING ,SET OF SET OF (different order2) | |
44507 | .*---------------------------------------------------------------------* | |
44508 | :xmp tab=0. | |
44509 | ||
44510 | <TC - DECODING ,SET OF SET OF (different order2)> | |
44511 | ||
44512 | <STATIC:ASN> | |
44513 | ||
44514 | TempA | |
44515 | ||
44516 | DEFINITIONS ::= | |
44517 | BEGIN | |
44518 | ||
44519 | BERPDU ::= SET OF SET OF INTEGER | |
44520 | ||
44521 | END | |
44522 | ||
44523 | <STATIC> | |
44524 | ||
44525 | import from TempA all; | |
44526 | ||
44527 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44528 | ||
44529 | const BERPDU myValue := { | |
44530 | { | |
44531 | 5, | |
44532 | 6, | |
44533 | 7 | |
44534 | }, | |
44535 | ||
44536 | { | |
44537 | 1, | |
44538 | 2, | |
44539 | 3 | |
44540 | } | |
44541 | }; | |
44542 | ||
44543 | ||
44544 | <TTCN_TC:EXEC> | |
44545 | ||
44546 | if (dec_BER_PDU('318031800201050201060201070000318002010102010202010300000000'O) == myValue) | |
44547 | ||
44548 | {setverdict(pass);} else {setverdict(fail);} | |
44549 | ||
44550 | ||
44551 | <RESULT> | |
44552 | ||
44553 | Overall verdict: pass | |
44554 | ||
44555 | <END_TC> | |
44556 | ||
44557 | :exmp. | |
44558 | ||
44559 | .*---------------------------------------------------------------------* | |
44560 | :h3. DECODING DER,TAGGED SET OF BOOLEAN | |
44561 | .*---------------------------------------------------------------------* | |
44562 | :xmp tab=0. | |
44563 | ||
44564 | <TC - DECODING DER,TAGGED SET OF BOOLEAN> | |
44565 | ||
44566 | <STATIC:ASN> | |
44567 | ||
44568 | TempA | |
44569 | ||
44570 | DEFINITIONS ::= | |
44571 | BEGIN | |
44572 | ||
44573 | BERPDU ::= [0] SET OF BOOLEAN | |
44574 | ||
44575 | END | |
44576 | ||
44577 | <STATIC> | |
44578 | ||
44579 | import from TempA all; | |
44580 | ||
44581 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44582 | ||
44583 | const BERPDU myValue := {true, false } | |
44584 | ||
44585 | ||
44586 | <TTCN_TC:EXEC> | |
44587 | ||
44588 | if (dec_BER_PDU('A00831060101000101FF'O) == myValue) | |
44589 | ||
44590 | {setverdict(pass);} else {setverdict(fail);} | |
44591 | ||
44592 | ||
44593 | <RESULT> | |
44594 | ||
44595 | Overall verdict: pass | |
44596 | ||
44597 | <END_TC> | |
44598 | ||
44599 | :exmp. | |
44600 | ||
44601 | .*---------------------------------------------------------------------* | |
44602 | :h3. DECODING CER,TAGGED SET OF BOOLEAN | |
44603 | .*---------------------------------------------------------------------* | |
44604 | :xmp tab=0. | |
44605 | ||
44606 | <TC - DECODING CER,TAGGED SET OF BOOLEAN> | |
44607 | ||
44608 | <STATIC:ASN> | |
44609 | ||
44610 | TempA | |
44611 | ||
44612 | DEFINITIONS ::= | |
44613 | BEGIN | |
44614 | ||
44615 | BERPDU ::= [0] SET OF BOOLEAN | |
44616 | ||
44617 | END | |
44618 | ||
44619 | <STATIC> | |
44620 | ||
44621 | import from TempA all; | |
44622 | ||
44623 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44624 | ||
44625 | const BERPDU myValue := {true, false } | |
44626 | ||
44627 | ||
44628 | <TTCN_TC:EXEC> | |
44629 | ||
44630 | if (dec_BER_PDU('A08031800101000101FF00000000'O) == myValue) | |
44631 | ||
44632 | {setverdict(pass);} else {setverdict(fail);} | |
44633 | ||
44634 | ||
44635 | <RESULT> | |
44636 | ||
44637 | Overall verdict: pass | |
44638 | ||
44639 | <END_TC> | |
44640 | ||
44641 | :exmp. | |
44642 | ||
44643 | .*---------------------------------------------------------------------* | |
44644 | :h3. DECODING ,TAGGED SET OF BOOLEAN (different order) | |
44645 | .*---------------------------------------------------------------------* | |
44646 | :xmp tab=0. | |
44647 | ||
44648 | <TC - DECODING ,TAGGED SET OF BOOLEAN (different order)> | |
44649 | ||
44650 | <STATIC:ASN> | |
44651 | ||
44652 | TempA | |
44653 | ||
44654 | DEFINITIONS ::= | |
44655 | BEGIN | |
44656 | ||
44657 | BERPDU ::= [0] SET OF BOOLEAN | |
44658 | ||
44659 | END | |
44660 | ||
44661 | <STATIC> | |
44662 | ||
44663 | import from TempA all; | |
44664 | ||
44665 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44666 | ||
44667 | const BERPDU myValue := {true, false } | |
44668 | ||
44669 | ||
44670 | <TTCN_TC:EXEC> | |
44671 | ||
44672 | if (dec_BER_PDU('A00831060101FF010100'O) == myValue) | |
44673 | ||
44674 | {setverdict(pass);} else {setverdict(fail);} | |
44675 | ||
44676 | ||
44677 | <RESULT> | |
44678 | ||
44679 | Overall verdict: pass | |
44680 | ||
44681 | <END_TC> | |
44682 | ||
44683 | :exmp. | |
44684 | ||
44685 | .*---------------------------------------------------------------------* | |
44686 | :h3. DECODING ,TAGGED SET OF BOOLEAN (different order2) | |
44687 | .*---------------------------------------------------------------------* | |
44688 | :xmp tab=0. | |
44689 | ||
44690 | <TC - DECODING ,TAGGED SET OF BOOLEAN (different order2)> | |
44691 | ||
44692 | <STATIC:ASN> | |
44693 | ||
44694 | TempA | |
44695 | ||
44696 | DEFINITIONS ::= | |
44697 | BEGIN | |
44698 | ||
44699 | BERPDU ::= [0] SET OF BOOLEAN | |
44700 | ||
44701 | END | |
44702 | ||
44703 | <STATIC> | |
44704 | ||
44705 | import from TempA all; | |
44706 | ||
44707 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44708 | ||
44709 | const BERPDU myValue := {true, false } | |
44710 | ||
44711 | ||
44712 | <TTCN_TC:EXEC> | |
44713 | ||
44714 | if (dec_BER_PDU('A08031800101FF01010000000000'O) == myValue) | |
44715 | ||
44716 | {setverdict(pass);} else {setverdict(fail);} | |
44717 | ||
44718 | ||
44719 | <RESULT> | |
44720 | ||
44721 | Overall verdict: pass | |
44722 | ||
44723 | <END_TC> | |
44724 | ||
44725 | :exmp. | |
44726 | ||
44727 | .*---------------------------------------------------------------------* | |
44728 | :h3. DECODING DER,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING | |
44729 | .*---------------------------------------------------------------------* | |
44730 | :xmp tab=0. | |
44731 | ||
44732 | <TC - DECODING DER,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING> | |
44733 | ||
44734 | <STATIC:ASN> | |
44735 | ||
44736 | TempA | |
44737 | ||
44738 | DEFINITIONS | |
44739 | ||
44740 | EXPLICIT TAGS | |
44741 | ::= | |
44742 | ||
44743 | BEGIN | |
44744 | ||
44745 | BERPDU ::= [0] SET OF BOOLEAN | |
44746 | ||
44747 | END | |
44748 | ||
44749 | <STATIC> | |
44750 | ||
44751 | import from TempA all; | |
44752 | ||
44753 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44754 | ||
44755 | const BERPDU myValue := {true, false } | |
44756 | ||
44757 | ||
44758 | <TTCN_TC:EXEC> | |
44759 | ||
44760 | if (dec_BER_PDU('A00831060101000101FF'O) == myValue) | |
44761 | ||
44762 | {setverdict(pass);} else {setverdict(fail);} | |
44763 | ||
44764 | ||
44765 | <RESULT> | |
44766 | ||
44767 | Overall verdict: pass | |
44768 | ||
44769 | <END_TC> | |
44770 | ||
44771 | :exmp. | |
44772 | ||
44773 | .*---------------------------------------------------------------------* | |
44774 | :h3. DECODING CER,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING | |
44775 | .*---------------------------------------------------------------------* | |
44776 | :xmp tab=0. | |
44777 | ||
44778 | <TC - DECODING CER,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING> | |
44779 | ||
44780 | <STATIC:ASN> | |
44781 | ||
44782 | TempA | |
44783 | ||
44784 | DEFINITIONS | |
44785 | ||
44786 | EXPLICIT TAGS | |
44787 | ::= | |
44788 | ||
44789 | BEGIN | |
44790 | ||
44791 | BERPDU ::= [0] SET OF BOOLEAN | |
44792 | ||
44793 | END | |
44794 | ||
44795 | <STATIC> | |
44796 | ||
44797 | import from TempA all; | |
44798 | ||
44799 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44800 | ||
44801 | const BERPDU myValue := {true, false } | |
44802 | ||
44803 | ||
44804 | <TTCN_TC:EXEC> | |
44805 | ||
44806 | if (dec_BER_PDU('A08031800101000101FF00000000'O) == myValue) | |
44807 | ||
44808 | {setverdict(pass);} else {setverdict(fail);} | |
44809 | ||
44810 | ||
44811 | <RESULT> | |
44812 | ||
44813 | Overall verdict: pass | |
44814 | ||
44815 | <END_TC> | |
44816 | ||
44817 | :exmp. | |
44818 | ||
44819 | .*---------------------------------------------------------------------* | |
44820 | :h3. DECODING ,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING (different order) | |
44821 | .*---------------------------------------------------------------------* | |
44822 | :xmp tab=0. | |
44823 | ||
44824 | <TC - DECODING ,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING (different order)> | |
44825 | ||
44826 | <STATIC:ASN> | |
44827 | ||
44828 | TempA | |
44829 | ||
44830 | DEFINITIONS | |
44831 | ||
44832 | EXPLICIT TAGS | |
44833 | ::= | |
44834 | ||
44835 | BEGIN | |
44836 | ||
44837 | BERPDU ::= [0] SET OF BOOLEAN | |
44838 | ||
44839 | END | |
44840 | ||
44841 | <STATIC> | |
44842 | ||
44843 | import from TempA all; | |
44844 | ||
44845 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44846 | ||
44847 | const BERPDU myValue := {true, false } | |
44848 | ||
44849 | ||
44850 | <TTCN_TC:EXEC> | |
44851 | ||
44852 | if (dec_BER_PDU('A00831060101FF010100'O) == myValue) | |
44853 | ||
44854 | {setverdict(pass);} else {setverdict(fail);} | |
44855 | ||
44856 | ||
44857 | <RESULT> | |
44858 | ||
44859 | Overall verdict: pass | |
44860 | ||
44861 | <END_TC> | |
44862 | ||
44863 | :exmp. | |
44864 | ||
44865 | .*---------------------------------------------------------------------* | |
44866 | :h3. DECODING ,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING (different order2) | |
44867 | .*---------------------------------------------------------------------* | |
44868 | :xmp tab=0. | |
44869 | ||
44870 | <TC - DECODING ,TAGGED SET OF BOOLEAN, EXPLICIT TAGGING (different order2)> | |
44871 | ||
44872 | <STATIC:ASN> | |
44873 | ||
44874 | TempA | |
44875 | ||
44876 | DEFINITIONS | |
44877 | ||
44878 | EXPLICIT TAGS | |
44879 | ::= | |
44880 | ||
44881 | BEGIN | |
44882 | ||
44883 | BERPDU ::= [0] SET OF BOOLEAN | |
44884 | ||
44885 | END | |
44886 | ||
44887 | <STATIC> | |
44888 | ||
44889 | import from TempA all; | |
44890 | ||
44891 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44892 | ||
44893 | const BERPDU myValue := {true, false } | |
44894 | ||
44895 | ||
44896 | <TTCN_TC:EXEC> | |
44897 | ||
44898 | if (dec_BER_PDU('A08031800101FF01010000000000'O) == myValue) | |
44899 | ||
44900 | {setverdict(pass);} else {setverdict(fail);} | |
44901 | ||
44902 | ||
44903 | <RESULT> | |
44904 | ||
44905 | Overall verdict: pass | |
44906 | ||
44907 | <END_TC> | |
44908 | ||
44909 | :exmp. | |
44910 | ||
44911 | .*---------------------------------------------------------------------* | |
44912 | :h3. DECODING DER,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING | |
44913 | .*---------------------------------------------------------------------* | |
44914 | :xmp tab=0. | |
44915 | ||
44916 | <TC - DECODING DER,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING> | |
44917 | ||
44918 | <STATIC:ASN> | |
44919 | ||
44920 | TempA | |
44921 | ||
44922 | DEFINITIONS | |
44923 | ||
44924 | IMPLICIT TAGS | |
44925 | ::= | |
44926 | ||
44927 | BEGIN | |
44928 | ||
44929 | BERPDU ::= [0] SET OF BOOLEAN | |
44930 | ||
44931 | END | |
44932 | ||
44933 | <STATIC> | |
44934 | ||
44935 | import from TempA all; | |
44936 | ||
44937 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44938 | ||
44939 | const BERPDU myValue := {true, false } | |
44940 | ||
44941 | ||
44942 | <TTCN_TC:EXEC> | |
44943 | ||
44944 | if (dec_BER_PDU('A0060101000101FF'O) == myValue) | |
44945 | ||
44946 | {setverdict(pass);} else {setverdict(fail);} | |
44947 | ||
44948 | ||
44949 | <RESULT> | |
44950 | ||
44951 | Overall verdict: pass | |
44952 | ||
44953 | <END_TC> | |
44954 | ||
44955 | :exmp. | |
44956 | ||
44957 | .*---------------------------------------------------------------------* | |
44958 | :h3. DECODING CER,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING | |
44959 | .*---------------------------------------------------------------------* | |
44960 | :xmp tab=0. | |
44961 | ||
44962 | <TC - DECODING CER,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING> | |
44963 | ||
44964 | <STATIC:ASN> | |
44965 | ||
44966 | TempA | |
44967 | ||
44968 | DEFINITIONS | |
44969 | ||
44970 | IMPLICIT TAGS | |
44971 | ::= | |
44972 | ||
44973 | BEGIN | |
44974 | ||
44975 | BERPDU ::= [0] SET OF BOOLEAN | |
44976 | ||
44977 | END | |
44978 | ||
44979 | <STATIC> | |
44980 | ||
44981 | import from TempA all; | |
44982 | ||
44983 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
44984 | ||
44985 | const BERPDU myValue := {true, false } | |
44986 | ||
44987 | ||
44988 | <TTCN_TC:EXEC> | |
44989 | ||
44990 | if (dec_BER_PDU('A0800101000101FF0000'O) == myValue) | |
44991 | ||
44992 | {setverdict(pass);} else {setverdict(fail);} | |
44993 | ||
44994 | ||
44995 | <RESULT> | |
44996 | ||
44997 | Overall verdict: pass | |
44998 | ||
44999 | <END_TC> | |
45000 | ||
45001 | :exmp. | |
45002 | ||
45003 | .*---------------------------------------------------------------------* | |
45004 | :h3. DECODING ,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING (different order) | |
45005 | .*---------------------------------------------------------------------* | |
45006 | :xmp tab=0. | |
45007 | ||
45008 | <TC - DECODING ,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING (different order)> | |
45009 | ||
45010 | <STATIC:ASN> | |
45011 | ||
45012 | TempA | |
45013 | ||
45014 | DEFINITIONS | |
45015 | ||
45016 | IMPLICIT TAGS | |
45017 | ::= | |
45018 | ||
45019 | BEGIN | |
45020 | ||
45021 | BERPDU ::= [0] SET OF BOOLEAN | |
45022 | ||
45023 | END | |
45024 | ||
45025 | <STATIC> | |
45026 | ||
45027 | import from TempA all; | |
45028 | ||
45029 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
45030 | ||
45031 | const BERPDU myValue := {true, false } | |
45032 | ||
45033 | ||
45034 | <TTCN_TC:EXEC> | |
45035 | ||
45036 | if (dec_BER_PDU('A0060101FF010100'O) == myValue) | |
45037 | ||
45038 | {setverdict(pass);} else {setverdict(fail);} | |
45039 | ||
45040 | ||
45041 | <RESULT> | |
45042 | ||
45043 | Overall verdict: pass | |
45044 | ||
45045 | <END_TC> | |
45046 | ||
45047 | :exmp. | |
45048 | ||
45049 | .*---------------------------------------------------------------------* | |
45050 | :h3. DECODING ,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING (different order2) | |
45051 | .*---------------------------------------------------------------------* | |
45052 | :xmp tab=0. | |
45053 | ||
45054 | <TC - DECODING ,TAGGED SET OF BOOLEAN, IMPLICIT TAGGING (different order2)> | |
45055 | ||
45056 | <STATIC:ASN> | |
45057 | ||
45058 | TempA | |
45059 | ||
45060 | DEFINITIONS | |
45061 | ||
45062 | IMPLICIT TAGS | |
45063 | ::= | |
45064 | ||
45065 | BEGIN | |
45066 | ||
45067 | BERPDU ::= [0] SET OF BOOLEAN | |
45068 | ||
45069 | END | |
45070 | ||
45071 | <STATIC> | |
45072 | ||
45073 | import from TempA all; | |
45074 | ||
45075 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
45076 | ||
45077 | const BERPDU myValue := {true, false } | |
45078 | ||
45079 | ||
45080 | <TTCN_TC:EXEC> | |
45081 | ||
45082 | if (dec_BER_PDU('A0800101FF0101000000'O) == myValue) | |
45083 | ||
45084 | {setverdict(pass);} else {setverdict(fail);} | |
45085 | ||
45086 | ||
45087 | <RESULT> | |
45088 | ||
45089 | Overall verdict: pass | |
45090 | ||
45091 | <END_TC> | |
45092 | ||
45093 | :exmp. | |
45094 | ||
45095 | .*---------------------------------------------------------------------* | |
45096 | :h3.CER + DER encoding of CHOICE - NULL | |
45097 | .*---------------------------------------------------------------------* | |
45098 | :xmp tab=0. | |
45099 | ||
45100 | <TC - CER + DER encoding of CHOICE - NULL> | |
45101 | ||
45102 | <STATIC:ASN> | |
45103 | ||
45104 | TempA | |
45105 | ||
45106 | DEFINITIONS ::= | |
45107 | BEGIN | |
45108 | ||
45109 | BERPDU ::= CHOICE | |
45110 | { | |
45111 | a NULL, | |
45112 | b BOOLEAN, | |
45113 | c INTEGER, | |
45114 | d ENUMERATED {first ,second ,third}, | |
45115 | e REAL, | |
45116 | f BIT STRING, | |
45117 | g OCTET STRING, | |
45118 | ||
45119 | h OBJECT IDENTIFIER, | |
45120 | i IA5String, | |
45121 | j CHOICE {x1 [1] BOOLEAN, | |
45122 | y1 [2] OCTET STRING}, | |
45123 | ||
45124 | k SEQUENCE{x2 NULL, | |
45125 | y2 BOOLEAN}, | |
45126 | ||
45127 | l SET { x3 BIT STRING, | |
45128 | y3 REAL}, | |
45129 | ||
45130 | m [3] SEQUENCE OF INTEGER, | |
45131 | n [4] SET OF BOOLEAN | |
45132 | } | |
45133 | ||
45134 | ||
45135 | END | |
45136 | ||
45137 | <STATIC> | |
45138 | ||
45139 | import from TempA all; | |
45140 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
45141 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
45142 | ||
45143 | const BERPDU myValue := {a := NULL} | |
45144 | ||
45145 | <TTCN_TC:EXEC> | |
45146 | ||
45147 | ||
45148 | ||
45149 | ||
45150 | if ((enc_DER_PDU(myValue) == '0500'O)and(enc_CER_PDU(myValue) == '0500'O)) {setverdict(pass);} else {setverdict(fail);} | |
45151 | ||
45152 | <RESULT> | |
45153 | ||
45154 | Overall verdict: pass | |
45155 | ||
45156 | <END_TC> | |
45157 | ||
45158 | :exmp. | |
45159 | ||
45160 | .*---------------------------------------------------------------------* | |
45161 | :h3.CER + DER encoding of CHOICE - BOOLEAN | |
45162 | .*---------------------------------------------------------------------* | |
45163 | :xmp tab=0. | |
45164 | ||
45165 | <TC - CER + DER encoding of CHOICE - BOOLEAN> | |
45166 | ||
45167 | <STATIC:ASN> | |
45168 | ||
45169 | TempA | |
45170 | ||
45171 | DEFINITIONS ::= | |
45172 | BEGIN | |
45173 | ||
45174 | BERPDU ::= CHOICE | |
45175 | { | |
45176 | a NULL, | |
45177 | b BOOLEAN, | |
45178 | c INTEGER, | |
45179 | d ENUMERATED {first ,second ,third}, | |
45180 | e REAL, | |
45181 | f BIT STRING, | |
45182 | g OCTET STRING, | |
45183 | ||
45184 | h OBJECT IDENTIFIER, | |
45185 | i IA5String, | |
45186 | j CHOICE {x1 [1] BOOLEAN, | |
45187 | y1 [2] OCTET STRING}, | |
45188 | ||
45189 | k SEQUENCE{x2 NULL, | |
45190 | y2 BOOLEAN}, | |
45191 | ||
45192 | l SET { x3 BIT STRING, | |
45193 | y3 REAL}, | |
45194 | ||
45195 | m [3] SEQUENCE OF INTEGER, | |
45196 | n [4] SET OF BOOLEAN | |
45197 | } | |
45198 | ||
45199 | ||
45200 | END | |
45201 | ||
45202 | <STATIC> | |
45203 | ||
45204 | import from TempA all; | |
45205 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
45206 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
45207 | ||
45208 | const BERPDU myValue := {b := true} | |
45209 | ||
45210 | <TTCN_TC:EXEC> | |
45211 | ||
45212 | ||
45213 | ||
45214 | ||
45215 | if ((enc_DER_PDU(myValue) == '0101FF'O)and(enc_CER_PDU(myValue) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);} | |
45216 | ||
45217 | <RESULT> | |
45218 | ||
45219 | Overall verdict: pass | |
45220 | ||
45221 | <END_TC> | |
45222 | ||
45223 | :exmp. | |
45224 | ||
45225 | .*---------------------------------------------------------------------* | |
45226 | :h3.CER + DER encoding of CHOICE - INTEGER | |
45227 | .*---------------------------------------------------------------------* | |
45228 | :xmp tab=0. | |
45229 | ||
45230 | <TC - CER + DER encoding of CHOICE - INTEGER> | |
45231 | ||
45232 | <STATIC:ASN> | |
45233 | ||
45234 | TempA | |
45235 | ||
45236 | DEFINITIONS ::= | |
45237 | BEGIN | |
45238 | ||
45239 | BERPDU ::= CHOICE | |
45240 | { | |
45241 | a NULL, | |
45242 | b BOOLEAN, | |
45243 | c INTEGER, | |
45244 | d ENUMERATED {first ,second ,third}, | |
45245 | e REAL, | |
45246 | f BIT STRING, | |
45247 | g OCTET STRING, | |
45248 | ||
45249 | h OBJECT IDENTIFIER, | |
45250 | i IA5String, | |
45251 | j CHOICE {x1 [1] BOOLEAN, | |
45252 | y1 [2] OCTET STRING}, | |
45253 | ||
45254 | k SEQUENCE{x2 NULL, | |
45255 | y2 BOOLEAN}, | |
45256 | ||
45257 | l SET { x3 BIT STRING, | |
45258 | y3 REAL}, | |
45259 | ||
45260 | m [3] SEQUENCE OF INTEGER, | |
45261 | n [4] SET OF BOOLEAN | |
45262 | } | |
45263 | ||
45264 | ||
45265 | END | |
45266 | ||
45267 | <STATIC> | |
45268 | ||
45269 | import from TempA all; | |
45270 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
45271 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
45272 | ||
45273 | const BERPDU myValue := {c := 2} | |
45274 | ||
45275 | <TTCN_TC:EXEC> | |
45276 | ||
45277 | ||
45278 | ||
45279 | ||
45280 | if ((enc_DER_PDU(myValue) == '020102'O)and(enc_CER_PDU(myValue) == '020102'O)) {setverdict(pass);} else {setverdict(fail);} | |
45281 | ||
45282 | <RESULT> | |
45283 | ||
45284 | Overall verdict: pass | |
45285 | ||
45286 | <END_TC> | |
45287 | ||
45288 | :exmp. | |
45289 | ||
45290 | .*---------------------------------------------------------------------* | |
45291 | :h3.CER + DER encoding of CHOICE - ENUMERATED | |
45292 | .*---------------------------------------------------------------------* | |
45293 | :xmp tab=0. | |
45294 | ||
45295 | <TC - CER + DER encoding of CHOICE - ENUMERATED> | |
45296 | ||
45297 | <STATIC:ASN> | |
45298 | ||
45299 | TempA | |
45300 | ||
45301 | DEFINITIONS ::= | |
45302 | BEGIN | |
45303 | ||
45304 | BERPDU ::= CHOICE | |
45305 | { | |
45306 | a NULL, | |
45307 | b BOOLEAN, | |
45308 | c INTEGER, | |
45309 | d ENUMERATED {first ,second ,third}, | |
45310 | e REAL, | |
45311 | f BIT STRING, | |
45312 | g OCTET STRING, | |
45313 | ||
45314 | h OBJECT IDENTIFIER, | |
45315 | i IA5String, | |
45316 | j CHOICE {x1 [1] BOOLEAN, | |
45317 | y1 [2] OCTET STRING}, | |
45318 | ||
45319 | k SEQUENCE{x2 NULL, | |
45320 | y2 BOOLEAN}, | |
45321 | ||
45322 | l SET { x3 BIT STRING, | |
45323 | y3 REAL}, | |
45324 | ||
45325 | m [3] SEQUENCE OF INTEGER, | |
45326 | n [4] SET OF BOOLEAN | |
45327 | } | |
45328 | ||
45329 | ||
45330 | END | |
45331 | ||
45332 | <STATIC> | |
45333 | ||
45334 | import from TempA all; | |
45335 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
45336 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
45337 | ||
45338 | const BERPDU myValue := {d := first} | |
45339 | ||
45340 | <TTCN_TC:EXEC> | |
45341 | ||
45342 | ||
45343 | ||
45344 | ||
45345 | if ((enc_DER_PDU(myValue) == '0A0100'O)and(enc_CER_PDU(myValue) == '0A0100'O)) {setverdict(pass);} else {setverdict(fail);} | |
45346 | ||
45347 | <RESULT> | |
45348 | ||
45349 | Overall verdict: pass | |
45350 | ||
45351 | <END_TC> | |
45352 | ||
45353 | :exmp. | |
45354 | ||
45355 | .*---------------------------------------------------------------------* | |
45356 | :h3.CER + DER encoding of CHOICE - REAL | |
45357 | .*---------------------------------------------------------------------* | |
45358 | :xmp tab=0. | |
45359 | ||
45360 | <TC - CER + DER encoding of CHOICE - REAL> | |
45361 | ||
45362 | <STATIC:ASN> | |
45363 | ||
45364 | TempA | |
45365 | ||
45366 | DEFINITIONS ::= | |
45367 | BEGIN | |
45368 | ||
45369 | BERPDU ::= CHOICE | |
45370 | { | |
45371 | a NULL, | |
45372 | b BOOLEAN, | |
45373 | c INTEGER, | |
45374 | d ENUMERATED {first ,second ,third}, | |
45375 | e REAL, | |
45376 | f BIT STRING, | |
45377 | g OCTET STRING, | |
45378 | ||
45379 | h OBJECT IDENTIFIER, | |
45380 | i IA5String, | |
45381 | j CHOICE {x1 [1] BOOLEAN, | |
45382 | y1 [2] OCTET STRING}, | |
45383 | ||
45384 | k SEQUENCE{x2 NULL, | |
45385 | y2 BOOLEAN}, | |
45386 | ||
45387 | l SET { x3 BIT STRING, | |
45388 | y3 REAL}, | |
45389 | ||
45390 | m [3] SEQUENCE OF INTEGER, | |
45391 | n [4] SET OF BOOLEAN | |
45392 | } | |
45393 | ||
45394 | ||
45395 | END | |
45396 | ||
45397 | <STATIC> | |
45398 | ||
45399 | import from TempA all; | |
45400 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
45401 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
45402 | ||
45403 | const BERPDU myValue := {e := 1.0} | |
45404 | ||
45405 | <TTCN_TC:EXEC> | |
45406 | ||
45407 | ||
45408 | ||
45409 | ||
45410 | if ((enc_DER_PDU(myValue) == '090603312E452B30'O)and(enc_CER_PDU(myValue) == '090603312E452B30'O)) {setverdict(pass);} else {setverdict(fail);} | |
45411 | ||
45412 | <RESULT> | |
45413 | ||
45414 | Overall verdict: pass | |
45415 | ||
45416 | <END_TC> | |
45417 | ||
45418 | :exmp. | |
45419 | ||
45420 | .*---------------------------------------------------------------------* | |
45421 | :h3.CER + DER encoding of CHOICE - BIT STRING | |
45422 | .*---------------------------------------------------------------------* | |
45423 | :xmp tab=0. | |
45424 | ||
45425 | <TC - CER + DER encoding of CHOICE - BIT STRING> | |
45426 | ||
45427 | <STATIC:ASN> | |
45428 | ||
45429 | TempA | |
45430 | ||
45431 | DEFINITIONS ::= | |
45432 | BEGIN | |
45433 | ||
45434 | BERPDU ::= CHOICE | |
45435 | { | |
45436 | a NULL, | |
45437 | b BOOLEAN, | |
45438 | c INTEGER, | |
45439 | d ENUMERATED {first ,second ,third}, | |
45440 | e REAL, | |
45441 | f BIT STRING, | |
45442 | g OCTET STRING, | |
45443 | ||
45444 | h OBJECT IDENTIFIER, | |
45445 | i IA5String, | |
45446 | j CHOICE {x1 [1] BOOLEAN, | |
45447 | y1 [2] OCTET STRING}, | |
45448 | ||
45449 | k SEQUENCE{x2 NULL, | |
45450 | y2 BOOLEAN}, | |
45451 | ||
45452 | l SET { x3 BIT STRING, | |
45453 | y3 REAL}, | |
45454 | ||
45455 | m [3] SEQUENCE OF INTEGER, | |
45456 | n [4] SET OF BOOLEAN | |
45457 | } | |
45458 | ||
45459 | ||
45460 | END | |
45461 | ||
45462 | <STATIC> | |
45463 | ||
45464 | import from TempA all; | |
45465 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
45466 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
45467 | ||
45468 | const BERPDU myValue := {f := '1'B} | |
45469 | ||
45470 | <TTCN_TC:EXEC> | |
45471 | ||
45472 | ||
45473 | ||
45474 | ||
45475 | if ((enc_DER_PDU(myValue) == '03020780'O)and(enc_CER_PDU(myValue) == '03020780'O)) {setverdict(pass);} else {setverdict(fail);} | |
45476 | ||
45477 | <RESULT> | |
45478 | ||
45479 | Overall verdict: pass | |
45480 | ||
45481 | <END_TC> | |
45482 | ||
45483 | :exmp. | |
45484 | ||
45485 | .*---------------------------------------------------------------------* | |
45486 | :h3.CER + DER encoding of CHOICE - OCTET STRING | |
45487 | .*---------------------------------------------------------------------* | |
45488 | :xmp tab=0. | |
45489 | ||
45490 | <TC - CER + DER encoding of CHOICE - OCTET STRING> | |
45491 | ||
45492 | <STATIC:ASN> | |
45493 | ||
45494 | TempA | |
45495 | ||
45496 | DEFINITIONS ::= | |
45497 | BEGIN | |
45498 | ||
45499 | BERPDU ::= CHOICE | |
45500 | { | |
45501 | a NULL, | |
45502 | b BOOLEAN, | |
45503 | c INTEGER, | |
45504 | d ENUMERATED {first ,second ,third}, | |
45505 | e REAL, | |
45506 | f BIT STRING, | |
45507 | g OCTET STRING, | |
45508 | ||
45509 | h OBJECT IDENTIFIER, | |
45510 | i IA5String, | |
45511 | j CHOICE {x1 [1] BOOLEAN, | |
45512 | y1 [2] OCTET STRING}, | |
45513 | ||
45514 | k SEQUENCE{x2 NULL, | |
45515 | y2 BOOLEAN}, | |
45516 | ||
45517 | l SET { x3 BIT STRING, | |
45518 | y3 REAL}, | |
45519 | ||
45520 | m [3] SEQUENCE OF INTEGER, | |
45521 | n [4] SET OF BOOLEAN | |
45522 | } | |
45523 | ||
45524 | ||
45525 | END | |
45526 | ||
45527 | <STATIC> | |
45528 | ||
45529 | import from TempA all; | |
45530 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
45531 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
45532 | ||
45533 | const BERPDU myValue := {g := 'FFFF'O} | |
45534 | ||
45535 | <TTCN_TC:EXEC> | |
45536 | ||
45537 | ||
45538 | ||
45539 | ||
45540 | if ((enc_DER_PDU(myValue) == '0402FFFF'O)and(enc_CER_PDU(myValue) == '0402FFFF'O)) {setverdict(pass);} else {setverdict(fail);} | |
45541 | ||
45542 | <RESULT> | |
45543 | ||
45544 | Overall verdict: pass | |
45545 | ||
45546 | <END_TC> | |
45547 | ||
45548 | :exmp. | |
45549 | ||
45550 | .*---------------------------------------------------------------------* | |
45551 | :h3.CER + DER encoding of CHOICE - OBJECT IDENTIFIER | |
45552 | .*---------------------------------------------------------------------* | |
45553 | :xmp tab=0. | |
45554 | ||
45555 | <TC - CER + DER encoding of CHOICE - OBJECT IDENTIFIER> | |
45556 | ||
45557 | <STATIC:ASN> | |
45558 | ||
45559 | TempA | |
45560 | ||
45561 | DEFINITIONS ::= | |
45562 | BEGIN | |
45563 | ||
45564 | BERPDU ::= CHOICE | |
45565 | { | |
45566 | a NULL, | |
45567 | b BOOLEAN, | |
45568 | c INTEGER, | |
45569 | d ENUMERATED {first ,second ,third}, | |
45570 | e REAL, | |
45571 | f BIT STRING, | |
45572 | g OCTET STRING, | |
45573 | ||
45574 | h OBJECT IDENTIFIER, | |
45575 | i IA5String, | |
45576 | j CHOICE {x1 [1] BOOLEAN, | |
45577 | y1 [2] OCTET STRING}, | |
45578 | ||
45579 | k SEQUENCE{x2 NULL, | |
45580 | y2 BOOLEAN}, | |
45581 | ||
45582 | l SET { x3 BIT STRING, | |
45583 | y3 REAL}, | |
45584 | ||
45585 | m [3] SEQUENCE OF INTEGER, | |
45586 | n [4] SET OF BOOLEAN | |
45587 | } | |
45588 | ||
45589 | ||
45590 | ||
45591 | myValue BERPDU ::= h : {itu-t(0) recommendation(0) a(2) b(3)} | |
45592 | ||
45593 | ||
45594 | ||
45595 | END | |
45596 | ||
45597 | <STATIC> | |
45598 | ||
45599 | import from TempA all; | |
45600 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
45601 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
45602 | ||
45603 | ||
45604 | <TTCN_TC:EXEC> | |
45605 | ||
45606 | ||
45607 | ||
45608 | ||
45609 | if ((enc_DER_PDU(myValue) == '0603000203'O)and(enc_CER_PDU(myValue) == '0603000203'O)) {setverdict(pass);} else {setverdict(fail);} | |
45610 | ||
45611 | <RESULT> | |
45612 | ||
45613 | Overall verdict: pass | |
45614 | ||
45615 | <END_TC> | |
45616 | ||
45617 | :exmp. | |
45618 | ||
45619 | .*---------------------------------------------------------------------* | |
45620 | :h3.CER + DER encoding of CHOICE - IA5String | |
45621 | .*---------------------------------------------------------------------* | |
45622 | :xmp tab=0. | |
45623 | ||
45624 | <TC - CER + DER encoding of CHOICE - IA5String> | |
45625 | ||
45626 | <STATIC:ASN> | |
45627 | ||
45628 | TempA | |
45629 | ||
45630 | DEFINITIONS ::= | |
45631 | BEGIN | |
45632 | ||
45633 | BERPDU ::= CHOICE | |
45634 | { | |
45635 | a NULL, | |
45636 | b BOOLEAN, | |
45637 | c INTEGER, | |
45638 | d ENUMERATED {first ,second ,third}, | |
45639 | e REAL, | |
45640 | f BIT STRING, | |
45641 | g OCTET STRING, | |
45642 | ||
45643 | h OBJECT IDENTIFIER, | |
45644 | i IA5String, | |
45645 | j CHOICE {x1 [1] BOOLEAN, | |
45646 | y1 [2] OCTET STRING}, | |
45647 | ||
45648 | k SEQUENCE{x2 NULL, | |
45649 | y2 BOOLEAN}, | |
45650 | ||
45651 | l SET { x3 BIT STRING, | |
45652 | y3 REAL}, | |
45653 | ||
45654 | m [3] SEQUENCE OF INTEGER, | |
45655 | n [4] SET OF BOOLEAN | |
45656 | } | |
45657 | ||
45658 | ||
45659 | END | |
45660 | ||
45661 | <STATIC> | |
45662 | ||
45663 | import from TempA all; | |
45664 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
45665 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
45666 | ||
45667 | const BERPDU myValue := {i := "ABC"} | |
45668 | ||
45669 | <TTCN_TC:EXEC> | |
45670 | ||
45671 | ||
45672 | ||
45673 | ||
45674 | if ((enc_DER_PDU(myValue) == '1603414243'O)and(enc_CER_PDU(myValue) == '1603414243'O)) {setverdict(pass);} else {setverdict(fail);} | |
45675 | ||
45676 | <RESULT> | |
45677 | ||
45678 | Overall verdict: pass | |
45679 | ||
45680 | <END_TC> | |
45681 | ||
45682 | :exmp. | |
45683 | ||
45684 | .*---------------------------------------------------------------------* | |
45685 | :h3.CER + DER encoding of CHOICE - CHOICE | |
45686 | .*---------------------------------------------------------------------* | |
45687 | :xmp tab=0. | |
45688 | ||
45689 | <TC - CER + DER encoding of CHOICE - CHOICE> | |
45690 | ||
45691 | <STATIC:ASN> | |
45692 | ||
45693 | TempA | |
45694 | ||
45695 | DEFINITIONS ::= | |
45696 | BEGIN | |
45697 | ||
45698 | BERPDU ::= CHOICE | |
45699 | { | |
45700 | a NULL, | |
45701 | b BOOLEAN, | |
45702 | c INTEGER, | |
45703 | d ENUMERATED {first ,second ,third}, | |
45704 | e REAL, | |
45705 | f BIT STRING, | |
45706 | g OCTET STRING, | |
45707 | ||
45708 | h OBJECT IDENTIFIER, | |
45709 | i IA5String, | |
45710 | j CHOICE {x1 [1] BOOLEAN, | |
45711 | y1 [2] OCTET STRING}, | |
45712 | ||
45713 | k SEQUENCE{x2 NULL, | |
45714 | y2 BOOLEAN}, | |
45715 | ||
45716 | l SET { x3 BIT STRING, | |
45717 | y3 REAL}, | |
45718 | ||
45719 | m [3] SEQUENCE OF INTEGER, | |
45720 | n [4] SET OF BOOLEAN | |
45721 | } | |
45722 | ||
45723 | ||
45724 | END | |
45725 | ||
45726 | <STATIC> | |
45727 | ||
45728 | import from TempA all; | |
45729 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
45730 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
45731 | ||
45732 | const BERPDU myValue := {j := {x1 := true } } | |
45733 | ||
45734 | <TTCN_TC:EXEC> | |
45735 | ||
45736 | ||
45737 | ||
45738 | ||
45739 | if ((enc_DER_PDU(myValue) == 'A1030101FF'O)and(enc_CER_PDU(myValue) == 'A1800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
45740 | ||
45741 | <RESULT> | |
45742 | ||
45743 | Overall verdict: pass | |
45744 | ||
45745 | <END_TC> | |
45746 | ||
45747 | :exmp. | |
45748 | ||
45749 | .*---------------------------------------------------------------------* | |
45750 | :h3.CER + DER encoding of CHOICE - SEQUENCE | |
45751 | .*---------------------------------------------------------------------* | |
45752 | :xmp tab=0. | |
45753 | ||
45754 | <TC - CER + DER encoding of CHOICE - SEQUENCE> | |
45755 | ||
45756 | <STATIC:ASN> | |
45757 | ||
45758 | TempA | |
45759 | ||
45760 | DEFINITIONS ::= | |
45761 | BEGIN | |
45762 | ||
45763 | BERPDU ::= CHOICE | |
45764 | { | |
45765 | a NULL, | |
45766 | b BOOLEAN, | |
45767 | c INTEGER, | |
45768 | d ENUMERATED {first ,second ,third}, | |
45769 | e REAL, | |
45770 | f BIT STRING, | |
45771 | g OCTET STRING, | |
45772 | ||
45773 | h OBJECT IDENTIFIER, | |
45774 | i IA5String, | |
45775 | j CHOICE {x1 [1] BOOLEAN, | |
45776 | y1 [2] OCTET STRING}, | |
45777 | ||
45778 | k SEQUENCE{x2 NULL, | |
45779 | y2 BOOLEAN}, | |
45780 | ||
45781 | l SET { x3 BIT STRING, | |
45782 | y3 REAL}, | |
45783 | ||
45784 | m [3] SEQUENCE OF INTEGER, | |
45785 | n [4] SET OF BOOLEAN | |
45786 | } | |
45787 | ||
45788 | ||
45789 | END | |
45790 | ||
45791 | <STATIC> | |
45792 | ||
45793 | import from TempA all; | |
45794 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
45795 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
45796 | ||
45797 | const BERPDU myValue := {k := {x2 := NULL, | |
45798 | ||
45799 | y2 := true } } | |
45800 | ||
45801 | <TTCN_TC:EXEC> | |
45802 | ||
45803 | ||
45804 | ||
45805 | ||
45806 | if ((enc_DER_PDU(myValue) == '300505000101FF'O)and(enc_CER_PDU(myValue) == '308005000101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
45807 | ||
45808 | <RESULT> | |
45809 | ||
45810 | Overall verdict: pass | |
45811 | ||
45812 | <END_TC> | |
45813 | ||
45814 | :exmp. | |
45815 | ||
45816 | .*---------------------------------------------------------------------* | |
45817 | :h3.CER + DER encoding of CHOICE - SET | |
45818 | .*---------------------------------------------------------------------* | |
45819 | :xmp tab=0. | |
45820 | ||
45821 | <TC - CER + DER encoding of CHOICE - SET> | |
45822 | ||
45823 | <STATIC:ASN> | |
45824 | ||
45825 | TempA | |
45826 | ||
45827 | DEFINITIONS ::= | |
45828 | BEGIN | |
45829 | ||
45830 | BERPDU ::= CHOICE | |
45831 | { | |
45832 | a NULL, | |
45833 | b BOOLEAN, | |
45834 | c INTEGER, | |
45835 | d ENUMERATED {first ,second ,third}, | |
45836 | e REAL, | |
45837 | f BIT STRING, | |
45838 | g OCTET STRING, | |
45839 | ||
45840 | h OBJECT IDENTIFIER, | |
45841 | i IA5String, | |
45842 | j CHOICE {x1 [1] BOOLEAN, | |
45843 | y1 [2] OCTET STRING}, | |
45844 | ||
45845 | k SEQUENCE{x2 NULL, | |
45846 | y2 BOOLEAN}, | |
45847 | ||
45848 | l SET { x3 BIT STRING, | |
45849 | y3 REAL}, | |
45850 | ||
45851 | m [3] SEQUENCE OF INTEGER, | |
45852 | n [4] SET OF BOOLEAN | |
45853 | } | |
45854 | ||
45855 | ||
45856 | END | |
45857 | ||
45858 | <STATIC> | |
45859 | ||
45860 | import from TempA all; | |
45861 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
45862 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
45863 | ||
45864 | const BERPDU myValue := {l := {y3 := 1.0 , | |
45865 | ||
45866 | x3 := '1'B } } | |
45867 | ||
45868 | <TTCN_TC:EXEC> | |
45869 | ||
45870 | ||
45871 | ||
45872 | ||
45873 | if ((enc_DER_PDU(myValue) == '310C03020780090603312E452B30'O)and(enc_CER_PDU(myValue) == '318003020780090603312E452B300000'O)) {setverdict(pass);} else {setverdict(fail);} | |
45874 | ||
45875 | <RESULT> | |
45876 | ||
45877 | Overall verdict: pass | |
45878 | ||
45879 | <END_TC> | |
45880 | ||
45881 | :exmp. | |
45882 | ||
45883 | .*---------------------------------------------------------------------* | |
45884 | :h3.CER + DER encoding of CHOICE - SEQUENCE OF | |
45885 | .*---------------------------------------------------------------------* | |
45886 | :xmp tab=0. | |
45887 | ||
45888 | <TC - CER + DER encoding of CHOICE - SEQUENCE OF> | |
45889 | ||
45890 | <STATIC:ASN> | |
45891 | ||
45892 | TempA | |
45893 | ||
45894 | DEFINITIONS ::= | |
45895 | BEGIN | |
45896 | ||
45897 | BERPDU ::= CHOICE | |
45898 | { | |
45899 | a NULL, | |
45900 | b BOOLEAN, | |
45901 | c INTEGER, | |
45902 | d ENUMERATED {first ,second ,third}, | |
45903 | e REAL, | |
45904 | f BIT STRING, | |
45905 | g OCTET STRING, | |
45906 | ||
45907 | h OBJECT IDENTIFIER, | |
45908 | i IA5String, | |
45909 | j CHOICE {x1 [1] BOOLEAN, | |
45910 | y1 [2] OCTET STRING}, | |
45911 | ||
45912 | k SEQUENCE{x2 NULL, | |
45913 | y2 BOOLEAN}, | |
45914 | ||
45915 | l SET { x3 BIT STRING, | |
45916 | y3 REAL}, | |
45917 | ||
45918 | m [3] SEQUENCE OF INTEGER, | |
45919 | n [4] SET OF BOOLEAN | |
45920 | } | |
45921 | ||
45922 | ||
45923 | END | |
45924 | ||
45925 | <STATIC> | |
45926 | ||
45927 | import from TempA all; | |
45928 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
45929 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
45930 | ||
45931 | const BERPDU myValue := {m := | |
45932 | { 1 ,2 } } | |
45933 | ||
45934 | <TTCN_TC:EXEC> | |
45935 | ||
45936 | ||
45937 | ||
45938 | ||
45939 | if ((enc_DER_PDU(myValue) == 'A3083006020101020102'O)and(enc_CER_PDU(myValue) == 'A380308002010102010200000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
45940 | ||
45941 | <RESULT> | |
45942 | ||
45943 | Overall verdict: pass | |
45944 | ||
45945 | <END_TC> | |
45946 | ||
45947 | :exmp. | |
45948 | ||
45949 | .*---------------------------------------------------------------------* | |
45950 | :h3.CER + DER encoding of CHOICE - SET OF | |
45951 | .*---------------------------------------------------------------------* | |
45952 | :xmp tab=0. | |
45953 | ||
45954 | <TC - CER + DER encoding of CHOICE - SET OF> | |
45955 | ||
45956 | <STATIC:ASN> | |
45957 | ||
45958 | TempA | |
45959 | ||
45960 | DEFINITIONS ::= | |
45961 | BEGIN | |
45962 | ||
45963 | BERPDU ::= CHOICE | |
45964 | { | |
45965 | a NULL, | |
45966 | b BOOLEAN, | |
45967 | c INTEGER, | |
45968 | d ENUMERATED {first ,second ,third}, | |
45969 | e REAL, | |
45970 | f BIT STRING, | |
45971 | g OCTET STRING, | |
45972 | ||
45973 | h OBJECT IDENTIFIER, | |
45974 | i IA5String, | |
45975 | j CHOICE {x1 [1] BOOLEAN, | |
45976 | y1 [2] OCTET STRING}, | |
45977 | ||
45978 | k SEQUENCE{x2 NULL, | |
45979 | y2 BOOLEAN}, | |
45980 | ||
45981 | l SET { x3 BIT STRING, | |
45982 | y3 REAL}, | |
45983 | ||
45984 | m [3] SEQUENCE OF INTEGER, | |
45985 | n [4] SET OF BOOLEAN | |
45986 | } | |
45987 | ||
45988 | ||
45989 | END | |
45990 | ||
45991 | <STATIC> | |
45992 | ||
45993 | import from TempA all; | |
45994 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
45995 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
45996 | ||
45997 | const BERPDU myValue := {n := | |
45998 | { true, true } } | |
45999 | ||
46000 | <TTCN_TC:EXEC> | |
46001 | ||
46002 | ||
46003 | ||
46004 | ||
46005 | if ((enc_DER_PDU(myValue) == 'A40831060101FF0101FF'O)and(enc_CER_PDU(myValue) == 'A48031800101FF0101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
46006 | ||
46007 | <RESULT> | |
46008 | ||
46009 | Overall verdict: pass | |
46010 | ||
46011 | <END_TC> | |
46012 | ||
46013 | :exmp. | |
46014 | ||
46015 | .*---------------------------------------------------------------------* | |
46016 | :h3.CER + DER encoding of CHOICE - Default IMPLICIT TAGS, CHOICE untagged | |
46017 | .*---------------------------------------------------------------------* | |
46018 | :xmp tab=0. | |
46019 | ||
46020 | <TC - CER + DER encoding of CHOICE - Default IMPLICIT TAGS, CHOICE untagged> | |
46021 | ||
46022 | <STATIC:ASN> | |
46023 | ||
46024 | TempA | |
46025 | ||
46026 | DEFINITIONS | |
46027 | ||
46028 | IMPLICIT TAGS | |
46029 | ||
46030 | ::= | |
46031 | ||
46032 | BEGIN | |
46033 | ||
46034 | BERPDU ::= CHOICE | |
46035 | { | |
46036 | b BOOLEAN, | |
46037 | c INTEGER | |
46038 | } | |
46039 | ||
46040 | ||
46041 | END | |
46042 | ||
46043 | <STATIC> | |
46044 | ||
46045 | import from TempA all; | |
46046 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46047 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46048 | ||
46049 | const BERPDU myValue := {b := true } | |
46050 | ||
46051 | <TTCN_TC:EXEC> | |
46052 | ||
46053 | ||
46054 | ||
46055 | ||
46056 | if ((enc_DER_PDU(myValue) == '0101FF'O)and(enc_CER_PDU(myValue) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);} | |
46057 | ||
46058 | ||
46059 | <RESULT> | |
46060 | ||
46061 | Overall verdict: pass | |
46062 | ||
46063 | <END_TC> | |
46064 | ||
46065 | :exmp. | |
46066 | ||
46067 | .*---------------------------------------------------------------------* | |
46068 | :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, CHOICE untagged | |
46069 | .*---------------------------------------------------------------------* | |
46070 | :xmp tab=0. | |
46071 | ||
46072 | <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, CHOICE untagged> | |
46073 | ||
46074 | <STATIC:ASN> | |
46075 | ||
46076 | TempA | |
46077 | ||
46078 | DEFINITIONS | |
46079 | ||
46080 | EXPLICIT TAGS | |
46081 | ||
46082 | ::= | |
46083 | ||
46084 | BEGIN | |
46085 | ||
46086 | BERPDU ::= CHOICE | |
46087 | { | |
46088 | b BOOLEAN, | |
46089 | c INTEGER | |
46090 | } | |
46091 | ||
46092 | ||
46093 | END | |
46094 | ||
46095 | <STATIC> | |
46096 | ||
46097 | import from TempA all; | |
46098 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46099 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46100 | ||
46101 | const BERPDU myValue := {b := true } | |
46102 | ||
46103 | <TTCN_TC:EXEC> | |
46104 | ||
46105 | ||
46106 | ||
46107 | ||
46108 | if ((enc_DER_PDU(myValue) == '0101FF'O)and(enc_CER_PDU(myValue) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);} | |
46109 | ||
46110 | ||
46111 | <RESULT> | |
46112 | ||
46113 | Overall verdict: pass | |
46114 | ||
46115 | <END_TC> | |
46116 | ||
46117 | :exmp. | |
46118 | ||
46119 | .*---------------------------------------------------------------------* | |
46120 | :h3.CER + DER encoding of CHOICE - No Default TAGS, CHOICE untagged | |
46121 | .*---------------------------------------------------------------------* | |
46122 | :xmp tab=0. | |
46123 | ||
46124 | <TC - CER + DER encoding of CHOICE - No Default TAGS, CHOICE untagged> | |
46125 | ||
46126 | <STATIC:ASN> | |
46127 | ||
46128 | TempA | |
46129 | ||
46130 | DEFINITIONS | |
46131 | ||
46132 | ||
46133 | ::= | |
46134 | ||
46135 | BEGIN | |
46136 | ||
46137 | BERPDU ::= CHOICE | |
46138 | { | |
46139 | b BOOLEAN, | |
46140 | c INTEGER | |
46141 | } | |
46142 | ||
46143 | ||
46144 | END | |
46145 | ||
46146 | <STATIC> | |
46147 | ||
46148 | import from TempA all; | |
46149 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46150 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46151 | ||
46152 | const BERPDU myValue := {b := true } | |
46153 | ||
46154 | <TTCN_TC:EXEC> | |
46155 | ||
46156 | ||
46157 | ||
46158 | ||
46159 | if ((enc_DER_PDU(myValue) == '0101FF'O)and(enc_CER_PDU(myValue) == '0101FF'O)) {setverdict(pass);} else {setverdict(fail);} | |
46160 | ||
46161 | ||
46162 | <RESULT> | |
46163 | ||
46164 | Overall verdict: pass | |
46165 | ||
46166 | <END_TC> | |
46167 | ||
46168 | :exmp. | |
46169 | ||
46170 | .*---------------------------------------------------------------------* | |
46171 | :h3.CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, CHOICE untagged | |
46172 | .*---------------------------------------------------------------------* | |
46173 | :xmp tab=0. | |
46174 | ||
46175 | <TC - CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, CHOICE untagged> | |
46176 | ||
46177 | <STATIC:ASN> | |
46178 | ||
46179 | TempA | |
46180 | ||
46181 | DEFINITIONS | |
46182 | ||
46183 | AUTOMATIC TAGS | |
46184 | ||
46185 | ::= | |
46186 | ||
46187 | BEGIN | |
46188 | ||
46189 | BERPDU ::= CHOICE | |
46190 | { | |
46191 | b BOOLEAN, | |
46192 | c INTEGER | |
46193 | } | |
46194 | ||
46195 | ||
46196 | END | |
46197 | ||
46198 | <STATIC> | |
46199 | ||
46200 | import from TempA all; | |
46201 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46202 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46203 | ||
46204 | const BERPDU myValue := {b := true } | |
46205 | ||
46206 | <TTCN_TC:EXEC> | |
46207 | ||
46208 | ||
46209 | ||
46210 | ||
46211 | if ((enc_DER_PDU(myValue) == '8001FF'O)and(enc_CER_PDU(myValue) == '8001FF'O)) {setverdict(pass);} else {setverdict(fail);} | |
46212 | ||
46213 | ||
46214 | <RESULT> | |
46215 | ||
46216 | Overall verdict: pass | |
46217 | ||
46218 | <END_TC> | |
46219 | ||
46220 | :exmp. | |
46221 | ||
46222 | .*---------------------------------------------------------------------* | |
46223 | :h3.CER + DER encoding of CHOICE - Default IMPLICIT TAGS, number-tagged CHOICE | |
46224 | .*---------------------------------------------------------------------* | |
46225 | :xmp tab=0. | |
46226 | ||
46227 | <TC - CER + DER encoding of CHOICE - Default IMPLICIT TAGS, number-tagged CHOICE> | |
46228 | ||
46229 | <STATIC:ASN> | |
46230 | ||
46231 | TempA | |
46232 | ||
46233 | DEFINITIONS | |
46234 | ||
46235 | IMPLICIT TAGS | |
46236 | ||
46237 | ::= | |
46238 | ||
46239 | BEGIN | |
46240 | ||
46241 | BERPDU ::= CHOICE | |
46242 | { | |
46243 | b [3] BOOLEAN, | |
46244 | c [6] INTEGER | |
46245 | } | |
46246 | ||
46247 | ||
46248 | END | |
46249 | ||
46250 | <STATIC> | |
46251 | ||
46252 | import from TempA all; | |
46253 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46254 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46255 | ||
46256 | const BERPDU myValue := {b := true } | |
46257 | ||
46258 | <TTCN_TC:EXEC> | |
46259 | ||
46260 | ||
46261 | ||
46262 | ||
46263 | if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);} | |
46264 | ||
46265 | ||
46266 | <RESULT> | |
46267 | ||
46268 | Overall verdict: pass | |
46269 | ||
46270 | <END_TC> | |
46271 | ||
46272 | :exmp. | |
46273 | ||
46274 | .*---------------------------------------------------------------------* | |
46275 | :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE | |
46276 | .*---------------------------------------------------------------------* | |
46277 | :xmp tab=0. | |
46278 | ||
46279 | <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE> | |
46280 | ||
46281 | <STATIC:ASN> | |
46282 | ||
46283 | TempA | |
46284 | ||
46285 | DEFINITIONS | |
46286 | ||
46287 | EXPLICIT TAGS | |
46288 | ||
46289 | ::= | |
46290 | ||
46291 | BEGIN | |
46292 | ||
46293 | BERPDU ::= CHOICE | |
46294 | { | |
46295 | b [3] BOOLEAN, | |
46296 | c [6] INTEGER | |
46297 | } | |
46298 | ||
46299 | ||
46300 | END | |
46301 | ||
46302 | <STATIC> | |
46303 | ||
46304 | import from TempA all; | |
46305 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46306 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46307 | ||
46308 | const BERPDU myValue := {b := true } | |
46309 | ||
46310 | <TTCN_TC:EXEC> | |
46311 | ||
46312 | ||
46313 | ||
46314 | ||
46315 | if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
46316 | ||
46317 | ||
46318 | <RESULT> | |
46319 | ||
46320 | Overall verdict: pass | |
46321 | ||
46322 | <END_TC> | |
46323 | ||
46324 | :exmp. | |
46325 | ||
46326 | .*---------------------------------------------------------------------* | |
46327 | :h3.CER + DER encoding of CHOICE - No Default TAGS, number-tagged CHOICE | |
46328 | .*---------------------------------------------------------------------* | |
46329 | :xmp tab=0. | |
46330 | ||
46331 | <TC - CER + DER encoding of CHOICE - No Default TAGS, number-tagged CHOICE> | |
46332 | ||
46333 | <STATIC:ASN> | |
46334 | ||
46335 | TempA | |
46336 | ||
46337 | DEFINITIONS ::= | |
46338 | BEGIN | |
46339 | ||
46340 | BERPDU ::= CHOICE | |
46341 | { | |
46342 | b [3] BOOLEAN, | |
46343 | c [6] INTEGER | |
46344 | } | |
46345 | ||
46346 | ||
46347 | END | |
46348 | ||
46349 | <STATIC> | |
46350 | ||
46351 | import from TempA all; | |
46352 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46353 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46354 | ||
46355 | const BERPDU myValue := {b := true } | |
46356 | ||
46357 | <TTCN_TC:EXEC> | |
46358 | ||
46359 | ||
46360 | ||
46361 | ||
46362 | if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
46363 | ||
46364 | ||
46365 | <RESULT> | |
46366 | ||
46367 | Overall verdict: pass | |
46368 | ||
46369 | <END_TC> | |
46370 | ||
46371 | :exmp. | |
46372 | ||
46373 | .*---------------------------------------------------------------------* | |
46374 | :h3.CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE | |
46375 | .*---------------------------------------------------------------------* | |
46376 | :xmp tab=0. | |
46377 | ||
46378 | <TC - CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE> | |
46379 | ||
46380 | <STATIC:ASN> | |
46381 | ||
46382 | TempA | |
46383 | ||
46384 | DEFINITIONS | |
46385 | ||
46386 | AUTOMATIC TAGS | |
46387 | ||
46388 | ::= | |
46389 | ||
46390 | BEGIN | |
46391 | ||
46392 | BERPDU ::= CHOICE | |
46393 | { | |
46394 | b [3] BOOLEAN, | |
46395 | c [6] INTEGER | |
46396 | } | |
46397 | ||
46398 | ||
46399 | END | |
46400 | ||
46401 | <STATIC> | |
46402 | ||
46403 | import from TempA all; | |
46404 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46405 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46406 | ||
46407 | const BERPDU myValue := {b := true } | |
46408 | ||
46409 | <TTCN_TC:EXEC> | |
46410 | ||
46411 | ||
46412 | ||
46413 | ||
46414 | if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);} | |
46415 | ||
46416 | ||
46417 | <RESULT> | |
46418 | ||
46419 | Overall verdict: pass | |
46420 | ||
46421 | <END_TC> | |
46422 | ||
46423 | :exmp. | |
46424 | ||
46425 | .*---------------------------------------------------------------------* | |
46426 | :h3.CER + DER encoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE | |
46427 | .*---------------------------------------------------------------------* | |
46428 | :xmp tab=0. | |
46429 | ||
46430 | <TC - CER + DER encoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE> | |
46431 | ||
46432 | <STATIC:ASN> | |
46433 | ||
46434 | TempA | |
46435 | ||
46436 | DEFINITIONS | |
46437 | ||
46438 | IMPLICIT TAGS | |
46439 | ||
46440 | ::= | |
46441 | ||
46442 | BEGIN | |
46443 | ||
46444 | BERPDU ::= CHOICE | |
46445 | { | |
46446 | b [3] IMPLICIT BOOLEAN, | |
46447 | c [6] INTEGER | |
46448 | } | |
46449 | ||
46450 | ||
46451 | END | |
46452 | ||
46453 | <STATIC> | |
46454 | ||
46455 | import from TempA all; | |
46456 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46457 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46458 | ||
46459 | const BERPDU myValue := {b := true } | |
46460 | ||
46461 | <TTCN_TC:EXEC> | |
46462 | ||
46463 | ||
46464 | ||
46465 | ||
46466 | if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);} | |
46467 | ||
46468 | ||
46469 | <RESULT> | |
46470 | ||
46471 | Overall verdict: pass | |
46472 | ||
46473 | <END_TC> | |
46474 | ||
46475 | :exmp. | |
46476 | ||
46477 | .*---------------------------------------------------------------------* | |
46478 | :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE | |
46479 | .*---------------------------------------------------------------------* | |
46480 | :xmp tab=0. | |
46481 | ||
46482 | <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE> | |
46483 | ||
46484 | <STATIC:ASN> | |
46485 | ||
46486 | TempA | |
46487 | ||
46488 | DEFINITIONS | |
46489 | ||
46490 | EXPLICIT TAGS | |
46491 | ||
46492 | ::= | |
46493 | ||
46494 | BEGIN | |
46495 | ||
46496 | BERPDU ::= CHOICE | |
46497 | { | |
46498 | b [3] IMPLICIT BOOLEAN, | |
46499 | c [6] INTEGER | |
46500 | } | |
46501 | ||
46502 | ||
46503 | END | |
46504 | ||
46505 | <STATIC> | |
46506 | ||
46507 | import from TempA all; | |
46508 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46509 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46510 | ||
46511 | const BERPDU myValue := {b := true } | |
46512 | ||
46513 | <TTCN_TC:EXEC> | |
46514 | ||
46515 | ||
46516 | ||
46517 | ||
46518 | if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);} | |
46519 | ||
46520 | ||
46521 | <RESULT> | |
46522 | ||
46523 | Overall verdict: pass | |
46524 | ||
46525 | <END_TC> | |
46526 | ||
46527 | :exmp. | |
46528 | ||
46529 | .*---------------------------------------------------------------------* | |
46530 | :h3.CER + DER encoding of CHOICE - No Default TAGS, fully-tagged CHOICE | |
46531 | .*---------------------------------------------------------------------* | |
46532 | :xmp tab=0. | |
46533 | ||
46534 | <TC - CER + DER encoding of CHOICE - No Default TAGS, fully-tagged CHOICE> | |
46535 | ||
46536 | <STATIC:ASN> | |
46537 | ||
46538 | TempA | |
46539 | ||
46540 | DEFINITIONS | |
46541 | ||
46542 | ||
46543 | ::= | |
46544 | ||
46545 | BEGIN | |
46546 | ||
46547 | BERPDU ::= CHOICE | |
46548 | { | |
46549 | b [3] IMPLICIT BOOLEAN, | |
46550 | c [6] INTEGER | |
46551 | } | |
46552 | ||
46553 | ||
46554 | END | |
46555 | ||
46556 | <STATIC> | |
46557 | ||
46558 | import from TempA all; | |
46559 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46560 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46561 | ||
46562 | const BERPDU myValue := {b := true } | |
46563 | ||
46564 | <TTCN_TC:EXEC> | |
46565 | ||
46566 | ||
46567 | ||
46568 | ||
46569 | if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);} | |
46570 | ||
46571 | ||
46572 | <RESULT> | |
46573 | ||
46574 | Overall verdict: pass | |
46575 | ||
46576 | <END_TC> | |
46577 | ||
46578 | :exmp. | |
46579 | ||
46580 | .*---------------------------------------------------------------------* | |
46581 | :h3.CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE | |
46582 | .*---------------------------------------------------------------------* | |
46583 | :xmp tab=0. | |
46584 | ||
46585 | <TC - CER + DER encoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE> | |
46586 | ||
46587 | <STATIC:ASN> | |
46588 | ||
46589 | TempA | |
46590 | ||
46591 | DEFINITIONS | |
46592 | ||
46593 | AUTOMATIC TAGS | |
46594 | ||
46595 | ::= | |
46596 | ||
46597 | BEGIN | |
46598 | ||
46599 | BERPDU ::= CHOICE | |
46600 | { | |
46601 | b [3] IMPLICIT BOOLEAN, | |
46602 | c [6] INTEGER | |
46603 | } | |
46604 | ||
46605 | ||
46606 | END | |
46607 | ||
46608 | <STATIC> | |
46609 | ||
46610 | import from TempA all; | |
46611 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46612 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46613 | ||
46614 | const BERPDU myValue := {b := true } | |
46615 | ||
46616 | <TTCN_TC:EXEC> | |
46617 | ||
46618 | ||
46619 | ||
46620 | ||
46621 | if ((enc_DER_PDU(myValue) == '8301FF'O)and(enc_CER_PDU(myValue) == '8301FF'O)) {setverdict(pass);} else {setverdict(fail);} | |
46622 | ||
46623 | ||
46624 | <RESULT> | |
46625 | ||
46626 | Overall verdict: pass | |
46627 | ||
46628 | <END_TC> | |
46629 | ||
46630 | :exmp. | |
46631 | ||
46632 | .*---------------------------------------------------------------------* | |
46633 | :h3.CER + DER encoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE | |
46634 | .*---------------------------------------------------------------------* | |
46635 | :xmp tab=0. | |
46636 | ||
46637 | <TC - CER + DER encoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE> | |
46638 | ||
46639 | <STATIC:ASN> | |
46640 | ||
46641 | TempA | |
46642 | ||
46643 | DEFINITIONS | |
46644 | ||
46645 | IMPLICIT TAGS | |
46646 | ||
46647 | ::= | |
46648 | ||
46649 | BEGIN | |
46650 | ||
46651 | BERPDU ::= CHOICE | |
46652 | { | |
46653 | b [3] EXPLICIT BOOLEAN, | |
46654 | c [6] INTEGER | |
46655 | } | |
46656 | ||
46657 | ||
46658 | END | |
46659 | ||
46660 | <STATIC> | |
46661 | ||
46662 | import from TempA all; | |
46663 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46664 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46665 | ||
46666 | const BERPDU myValue := {b := true } | |
46667 | ||
46668 | <TTCN_TC:EXEC> | |
46669 | ||
46670 | ||
46671 | ||
46672 | ||
46673 | if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
46674 | ||
46675 | ||
46676 | <RESULT> | |
46677 | ||
46678 | Overall verdict: pass | |
46679 | ||
46680 | <END_TC> | |
46681 | ||
46682 | :exmp. | |
46683 | ||
46684 | .*---------------------------------------------------------------------* | |
46685 | :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE | |
46686 | .*---------------------------------------------------------------------* | |
46687 | :xmp tab=0. | |
46688 | ||
46689 | <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE> | |
46690 | ||
46691 | <STATIC:ASN> | |
46692 | ||
46693 | TempA | |
46694 | ||
46695 | DEFINITIONS | |
46696 | ||
46697 | EXPLICIT TAGS | |
46698 | ||
46699 | ::= | |
46700 | ||
46701 | BEGIN | |
46702 | ||
46703 | BERPDU ::= CHOICE | |
46704 | { | |
46705 | b [3] EXPLICIT BOOLEAN, | |
46706 | c [6] INTEGER | |
46707 | } | |
46708 | ||
46709 | ||
46710 | END | |
46711 | ||
46712 | <STATIC> | |
46713 | ||
46714 | import from TempA all; | |
46715 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46716 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46717 | ||
46718 | const BERPDU myValue := {b := true } | |
46719 | ||
46720 | <TTCN_TC:EXEC> | |
46721 | ||
46722 | ||
46723 | ||
46724 | ||
46725 | if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
46726 | ||
46727 | ||
46728 | <RESULT> | |
46729 | ||
46730 | Overall verdict: pass | |
46731 | ||
46732 | <END_TC> | |
46733 | ||
46734 | :exmp. | |
46735 | ||
46736 | .*---------------------------------------------------------------------* | |
46737 | :h3.CER + DER encoding of CHOICE - No Default TAGS, fully-tagged CHOICE | |
46738 | .*---------------------------------------------------------------------* | |
46739 | :xmp tab=0. | |
46740 | ||
46741 | <TC - CER + DER encoding of CHOICE - No Default TAGS, fully-tagged CHOICE> | |
46742 | ||
46743 | <STATIC:ASN> | |
46744 | ||
46745 | TempA | |
46746 | ||
46747 | DEFINITIONS | |
46748 | ||
46749 | ||
46750 | ::= | |
46751 | ||
46752 | BEGIN | |
46753 | ||
46754 | BERPDU ::= CHOICE | |
46755 | { | |
46756 | b [3] EXPLICIT BOOLEAN, | |
46757 | c [6] INTEGER | |
46758 | } | |
46759 | ||
46760 | ||
46761 | END | |
46762 | ||
46763 | <STATIC> | |
46764 | ||
46765 | import from TempA all; | |
46766 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46767 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46768 | ||
46769 | const BERPDU myValue := {b := true } | |
46770 | ||
46771 | <TTCN_TC:EXEC> | |
46772 | ||
46773 | ||
46774 | ||
46775 | ||
46776 | if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
46777 | ||
46778 | ||
46779 | <RESULT> | |
46780 | ||
46781 | Overall verdict: pass | |
46782 | ||
46783 | <END_TC> | |
46784 | ||
46785 | :exmp. | |
46786 | ||
46787 | .*---------------------------------------------------------------------* | |
46788 | :h3.CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE | |
46789 | .*---------------------------------------------------------------------* | |
46790 | :xmp tab=0. | |
46791 | ||
46792 | <TC - CER + DER encoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE> | |
46793 | ||
46794 | <STATIC:ASN> | |
46795 | ||
46796 | TempA | |
46797 | ||
46798 | DEFINITIONS | |
46799 | ||
46800 | EXPLICIT TAGS | |
46801 | ||
46802 | ::= | |
46803 | ||
46804 | BEGIN | |
46805 | ||
46806 | BERPDU ::= CHOICE | |
46807 | { | |
46808 | b [3] EXPLICIT BOOLEAN, | |
46809 | c [6] INTEGER | |
46810 | } | |
46811 | ||
46812 | ||
46813 | END | |
46814 | ||
46815 | <STATIC> | |
46816 | ||
46817 | import from TempA all; | |
46818 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46819 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46820 | ||
46821 | const BERPDU myValue := {b := true } | |
46822 | ||
46823 | <TTCN_TC:EXEC> | |
46824 | ||
46825 | ||
46826 | ||
46827 | ||
46828 | if ((enc_DER_PDU(myValue) == 'A3030101FF'O)and(enc_CER_PDU(myValue) == 'A3800101FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
46829 | ||
46830 | ||
46831 | <RESULT> | |
46832 | ||
46833 | Overall verdict: pass | |
46834 | ||
46835 | <END_TC> | |
46836 | ||
46837 | :exmp. | |
46838 | ||
46839 | .*---------------------------------------------------------------------* | |
46840 | :h3.CER + DER encoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE, | |
46841 | .*---------------------------------------------------------------------* | |
46842 | :xmp tab=0. | |
46843 | ||
46844 | <TC - CER + DER encoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,> | |
46845 | ||
46846 | <STATIC:ASN> | |
46847 | ||
46848 | TempA | |
46849 | ||
46850 | DEFINITIONS | |
46851 | ||
46852 | IMPLICIT TAGS | |
46853 | ||
46854 | ::= | |
46855 | ||
46856 | BEGIN | |
46857 | ||
46858 | BERPDU ::= [0] CHOICE | |
46859 | { | |
46860 | b [3] BOOLEAN, | |
46861 | c [6] INTEGER | |
46862 | } | |
46863 | ||
46864 | ||
46865 | END | |
46866 | ||
46867 | <STATIC> | |
46868 | ||
46869 | import from TempA all; | |
46870 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46871 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46872 | ||
46873 | const BERPDU myValue := {b := true } | |
46874 | ||
46875 | <TTCN_TC:EXEC> | |
46876 | ||
46877 | ||
46878 | ||
46879 | ||
46880 | if ((enc_DER_PDU(myValue) == 'A0038301FF'O)and(enc_CER_PDU(myValue) == 'A0808301FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
46881 | ||
46882 | ||
46883 | <RESULT> | |
46884 | ||
46885 | Overall verdict: pass | |
46886 | ||
46887 | <END_TC> | |
46888 | ||
46889 | :exmp. | |
46890 | ||
46891 | .*---------------------------------------------------------------------* | |
46892 | :h3.CER + DER encoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE, | |
46893 | .*---------------------------------------------------------------------* | |
46894 | :xmp tab=0. | |
46895 | ||
46896 | <TC - CER + DER encoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,> | |
46897 | ||
46898 | <STATIC:ASN> | |
46899 | ||
46900 | TempA | |
46901 | ||
46902 | DEFINITIONS | |
46903 | ||
46904 | EXPLICIT TAGS | |
46905 | ||
46906 | ::= | |
46907 | ||
46908 | BEGIN | |
46909 | ||
46910 | BERPDU ::= [0] CHOICE | |
46911 | { | |
46912 | b [3] BOOLEAN, | |
46913 | c [6] INTEGER | |
46914 | } | |
46915 | ||
46916 | ||
46917 | END | |
46918 | ||
46919 | <STATIC> | |
46920 | ||
46921 | import from TempA all; | |
46922 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46923 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46924 | ||
46925 | const BERPDU myValue := {b := true } | |
46926 | ||
46927 | <TTCN_TC:EXEC> | |
46928 | ||
46929 | ||
46930 | ||
46931 | ||
46932 | if ((enc_DER_PDU(myValue) == 'A005A3030101FF'O)and(enc_CER_PDU(myValue) == 'A080A3800101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
46933 | ||
46934 | ||
46935 | <RESULT> | |
46936 | ||
46937 | Overall verdict: pass | |
46938 | ||
46939 | <END_TC> | |
46940 | ||
46941 | :exmp. | |
46942 | ||
46943 | .*---------------------------------------------------------------------* | |
46944 | :h3.CER + DER encoding of CHOICE, NO DEFAULT, TAGGED CHOICE, | |
46945 | .*---------------------------------------------------------------------* | |
46946 | :xmp tab=0. | |
46947 | ||
46948 | <TC - CER + DER encoding of CHOICE, NO DEFAULT, TAGGED CHOICE,> | |
46949 | ||
46950 | <STATIC:ASN> | |
46951 | ||
46952 | TempA | |
46953 | ||
46954 | DEFINITIONS | |
46955 | ||
46956 | ||
46957 | ||
46958 | ::= | |
46959 | ||
46960 | BEGIN | |
46961 | ||
46962 | BERPDU ::= [0] CHOICE | |
46963 | { | |
46964 | b [3] BOOLEAN, | |
46965 | c [6] INTEGER | |
46966 | } | |
46967 | ||
46968 | ||
46969 | END | |
46970 | ||
46971 | <STATIC> | |
46972 | ||
46973 | import from TempA all; | |
46974 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
46975 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
46976 | ||
46977 | const BERPDU myValue := {b := true } | |
46978 | ||
46979 | <TTCN_TC:EXEC> | |
46980 | ||
46981 | ||
46982 | ||
46983 | ||
46984 | if ((enc_DER_PDU(myValue) == 'A005A3030101FF'O)and(enc_CER_PDU(myValue) == 'A080A3800101FF00000000'O)) {setverdict(pass);} else {setverdict(fail);} | |
46985 | ||
46986 | ||
46987 | <RESULT> | |
46988 | ||
46989 | Overall verdict: pass | |
46990 | ||
46991 | <END_TC> | |
46992 | ||
46993 | :exmp. | |
46994 | ||
46995 | .*---------------------------------------------------------------------* | |
46996 | :h3.CER + DER encoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE, | |
46997 | .*---------------------------------------------------------------------* | |
46998 | :xmp tab=0. | |
46999 | ||
47000 | <TC - CER + DER encoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,> | |
47001 | ||
47002 | <STATIC:ASN> | |
47003 | ||
47004 | TempA | |
47005 | ||
47006 | DEFINITIONS | |
47007 | ||
47008 | AUTOMATIC TAGS | |
47009 | ||
47010 | ::= | |
47011 | ||
47012 | BEGIN | |
47013 | ||
47014 | BERPDU ::= [0] CHOICE | |
47015 | { | |
47016 | b [3] BOOLEAN, | |
47017 | c [6] INTEGER | |
47018 | } | |
47019 | ||
47020 | ||
47021 | END | |
47022 | ||
47023 | <STATIC> | |
47024 | ||
47025 | import from TempA all; | |
47026 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
47027 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
47028 | ||
47029 | const BERPDU myValue := {b := true } | |
47030 | ||
47031 | <TTCN_TC:EXEC> | |
47032 | ||
47033 | ||
47034 | ||
47035 | ||
47036 | if ((enc_DER_PDU(myValue) == 'A0038301FF'O)and(enc_CER_PDU(myValue) == 'A0808301FF0000'O)) {setverdict(pass);} else {setverdict(fail);} | |
47037 | ||
47038 | ||
47039 | <RESULT> | |
47040 | ||
47041 | Overall verdict: pass | |
47042 | ||
47043 | <END_TC> | |
47044 | ||
47045 | :exmp. | |
47046 | ||
47047 | .*---------------------------------------------------------------------* | |
47048 | :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - NULL | |
47049 | .*---------------------------------------------------------------------* | |
47050 | :xmp tab=0. | |
47051 | ||
47052 | <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - NULL> | |
47053 | ||
47054 | <STATIC:ASN> | |
47055 | ||
47056 | TempA | |
47057 | ||
47058 | DEFINITIONS ::= | |
47059 | BEGIN | |
47060 | BERPDU ::= CHOICE | |
47061 | { | |
47062 | a NULL, | |
47063 | b BOOLEAN, | |
47064 | c INTEGER, | |
47065 | d ENUMERATED {first ,second ,third}, | |
47066 | e REAL, | |
47067 | f BIT STRING, | |
47068 | g OCTET STRING, | |
47069 | ||
47070 | h OBJECT IDENTIFIER, | |
47071 | i IA5String, | |
47072 | j CHOICE {x1 [1] BOOLEAN, | |
47073 | y1 [2] OCTET STRING}, | |
47074 | ||
47075 | k SEQUENCE{x2 NULL, | |
47076 | y2 BOOLEAN}, | |
47077 | ||
47078 | l SET { x3 BIT STRING, | |
47079 | y3 REAL}, | |
47080 | ||
47081 | m [3] SEQUENCE OF INTEGER, | |
47082 | n [4] SET OF BOOLEAN | |
47083 | } | |
47084 | END | |
47085 | ||
47086 | <STATIC> | |
47087 | ||
47088 | import from TempA all; | |
47089 | ||
47090 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
47091 | const BERPDU myValue := {a := NULL} | |
47092 | ||
47093 | <TTCN_TC:EXEC> | |
47094 | ||
47095 | if (dec_BER_PDU('0500'O) == myValue) | |
47096 | ||
47097 | ||
47098 | {setverdict(pass);} else {setverdict(fail);} | |
47099 | ||
47100 | ||
47101 | <RESULT> | |
47102 | ||
47103 | Overall verdict: pass | |
47104 | ||
47105 | <END_TC> | |
47106 | ||
47107 | :exmp. | |
47108 | ||
47109 | .*---------------------------------------------------------------------* | |
47110 | :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - BOOLEAN | |
47111 | .*---------------------------------------------------------------------* | |
47112 | :xmp tab=0. | |
47113 | ||
47114 | <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - BOOLEAN> | |
47115 | ||
47116 | <STATIC:ASN> | |
47117 | ||
47118 | TempA | |
47119 | ||
47120 | DEFINITIONS ::= | |
47121 | BEGIN | |
47122 | BERPDU ::= CHOICE | |
47123 | { | |
47124 | a NULL, | |
47125 | b BOOLEAN, | |
47126 | c INTEGER, | |
47127 | d ENUMERATED {first ,second ,third}, | |
47128 | e REAL, | |
47129 | f BIT STRING, | |
47130 | g OCTET STRING, | |
47131 | ||
47132 | h OBJECT IDENTIFIER, | |
47133 | i IA5String, | |
47134 | j CHOICE {x1 [1] BOOLEAN, | |
47135 | y1 [2] OCTET STRING}, | |
47136 | ||
47137 | k SEQUENCE{x2 NULL, | |
47138 | y2 BOOLEAN}, | |
47139 | ||
47140 | l SET { x3 BIT STRING, | |
47141 | y3 REAL}, | |
47142 | ||
47143 | m [3] SEQUENCE OF INTEGER, | |
47144 | n [4] SET OF BOOLEAN | |
47145 | } | |
47146 | END | |
47147 | ||
47148 | <STATIC> | |
47149 | ||
47150 | import from TempA all; | |
47151 | ||
47152 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
47153 | const BERPDU myValue := {b := true} | |
47154 | ||
47155 | <TTCN_TC:EXEC> | |
47156 | ||
47157 | if (dec_BER_PDU('0101FF'O) == myValue) | |
47158 | ||
47159 | ||
47160 | {setverdict(pass);} else {setverdict(fail);} | |
47161 | ||
47162 | ||
47163 | <RESULT> | |
47164 | ||
47165 | Overall verdict: pass | |
47166 | ||
47167 | <END_TC> | |
47168 | ||
47169 | :exmp. | |
47170 | ||
47171 | .*---------------------------------------------------------------------* | |
47172 | :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - INTEGER | |
47173 | .*---------------------------------------------------------------------* | |
47174 | :xmp tab=0. | |
47175 | ||
47176 | <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - INTEGER> | |
47177 | ||
47178 | <STATIC:ASN> | |
47179 | ||
47180 | TempA | |
47181 | ||
47182 | DEFINITIONS ::= | |
47183 | BEGIN | |
47184 | BERPDU ::= CHOICE | |
47185 | { | |
47186 | a NULL, | |
47187 | b BOOLEAN, | |
47188 | c INTEGER, | |
47189 | d ENUMERATED {first ,second ,third}, | |
47190 | e REAL, | |
47191 | f BIT STRING, | |
47192 | g OCTET STRING, | |
47193 | ||
47194 | h OBJECT IDENTIFIER, | |
47195 | i IA5String, | |
47196 | j CHOICE {x1 [1] BOOLEAN, | |
47197 | y1 [2] OCTET STRING}, | |
47198 | ||
47199 | k SEQUENCE{x2 NULL, | |
47200 | y2 BOOLEAN}, | |
47201 | ||
47202 | l SET { x3 BIT STRING, | |
47203 | y3 REAL}, | |
47204 | ||
47205 | m [3] SEQUENCE OF INTEGER, | |
47206 | n [4] SET OF BOOLEAN | |
47207 | } | |
47208 | END | |
47209 | ||
47210 | <STATIC> | |
47211 | ||
47212 | import from TempA all; | |
47213 | ||
47214 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
47215 | const BERPDU myValue := {c := 2} | |
47216 | ||
47217 | <TTCN_TC:EXEC> | |
47218 | ||
47219 | if (dec_BER_PDU('020102'O) == myValue) | |
47220 | ||
47221 | ||
47222 | {setverdict(pass);} else {setverdict(fail);} | |
47223 | ||
47224 | ||
47225 | <RESULT> | |
47226 | ||
47227 | Overall verdict: pass | |
47228 | ||
47229 | <END_TC> | |
47230 | ||
47231 | :exmp. | |
47232 | ||
47233 | .*---------------------------------------------------------------------* | |
47234 | :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - ENUMERATED | |
47235 | .*---------------------------------------------------------------------* | |
47236 | :xmp tab=0. | |
47237 | ||
47238 | <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - ENUMERATED> | |
47239 | ||
47240 | <STATIC:ASN> | |
47241 | ||
47242 | TempA | |
47243 | ||
47244 | DEFINITIONS ::= | |
47245 | BEGIN | |
47246 | BERPDU ::= CHOICE | |
47247 | { | |
47248 | a NULL, | |
47249 | b BOOLEAN, | |
47250 | c INTEGER, | |
47251 | d ENUMERATED {first ,second ,third}, | |
47252 | e REAL, | |
47253 | f BIT STRING, | |
47254 | g OCTET STRING, | |
47255 | ||
47256 | h OBJECT IDENTIFIER, | |
47257 | i IA5String, | |
47258 | j CHOICE {x1 [1] BOOLEAN, | |
47259 | y1 [2] OCTET STRING}, | |
47260 | ||
47261 | k SEQUENCE{x2 NULL, | |
47262 | y2 BOOLEAN}, | |
47263 | ||
47264 | l SET { x3 BIT STRING, | |
47265 | y3 REAL}, | |
47266 | ||
47267 | m [3] SEQUENCE OF INTEGER, | |
47268 | n [4] SET OF BOOLEAN | |
47269 | } | |
47270 | END | |
47271 | ||
47272 | <STATIC> | |
47273 | ||
47274 | import from TempA all; | |
47275 | ||
47276 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
47277 | const BERPDU myValue := {d := first} | |
47278 | ||
47279 | <TTCN_TC:EXEC> | |
47280 | ||
47281 | if (dec_BER_PDU('0A0100'O) == myValue) | |
47282 | ||
47283 | ||
47284 | {setverdict(pass);} else {setverdict(fail);} | |
47285 | ||
47286 | ||
47287 | <RESULT> | |
47288 | ||
47289 | Overall verdict: pass | |
47290 | ||
47291 | <END_TC> | |
47292 | ||
47293 | :exmp. | |
47294 | ||
47295 | .*---------------------------------------------------------------------* | |
47296 | :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - BIT STRING | |
47297 | .*---------------------------------------------------------------------* | |
47298 | :xmp tab=0. | |
47299 | ||
47300 | <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - BIT STRING> | |
47301 | ||
47302 | <STATIC:ASN> | |
47303 | ||
47304 | TempA | |
47305 | ||
47306 | DEFINITIONS ::= | |
47307 | BEGIN | |
47308 | BERPDU ::= CHOICE | |
47309 | { | |
47310 | a NULL, | |
47311 | b BOOLEAN, | |
47312 | c INTEGER, | |
47313 | d ENUMERATED {first ,second ,third}, | |
47314 | e REAL, | |
47315 | f BIT STRING, | |
47316 | g OCTET STRING, | |
47317 | ||
47318 | h OBJECT IDENTIFIER, | |
47319 | i IA5String, | |
47320 | j CHOICE {x1 [1] BOOLEAN, | |
47321 | y1 [2] OCTET STRING}, | |
47322 | ||
47323 | k SEQUENCE{x2 NULL, | |
47324 | y2 BOOLEAN}, | |
47325 | ||
47326 | l SET { x3 BIT STRING, | |
47327 | y3 REAL}, | |
47328 | ||
47329 | m [3] SEQUENCE OF INTEGER, | |
47330 | n [4] SET OF BOOLEAN | |
47331 | } | |
47332 | END | |
47333 | ||
47334 | <STATIC> | |
47335 | ||
47336 | import from TempA all; | |
47337 | ||
47338 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
47339 | const BERPDU myValue := {f := '1'B} | |
47340 | ||
47341 | <TTCN_TC:EXEC> | |
47342 | ||
47343 | if (dec_BER_PDU('03020780'O) == myValue) | |
47344 | ||
47345 | ||
47346 | {setverdict(pass);} else {setverdict(fail);} | |
47347 | ||
47348 | ||
47349 | <RESULT> | |
47350 | ||
47351 | Overall verdict: pass | |
47352 | ||
47353 | <END_TC> | |
47354 | ||
47355 | :exmp. | |
47356 | ||
47357 | .*---------------------------------------------------------------------* | |
47358 | :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - OCTET STRING | |
47359 | .*---------------------------------------------------------------------* | |
47360 | :xmp tab=0. | |
47361 | ||
47362 | <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - OCTET STRING> | |
47363 | ||
47364 | <STATIC:ASN> | |
47365 | ||
47366 | TempA | |
47367 | ||
47368 | DEFINITIONS ::= | |
47369 | BEGIN | |
47370 | BERPDU ::= CHOICE | |
47371 | { | |
47372 | a NULL, | |
47373 | b BOOLEAN, | |
47374 | c INTEGER, | |
47375 | d ENUMERATED {first ,second ,third}, | |
47376 | e REAL, | |
47377 | f BIT STRING, | |
47378 | g OCTET STRING, | |
47379 | ||
47380 | h OBJECT IDENTIFIER, | |
47381 | i IA5String, | |
47382 | j CHOICE {x1 [1] BOOLEAN, | |
47383 | y1 [2] OCTET STRING}, | |
47384 | ||
47385 | k SEQUENCE{x2 NULL, | |
47386 | y2 BOOLEAN}, | |
47387 | ||
47388 | l SET { x3 BIT STRING, | |
47389 | y3 REAL}, | |
47390 | ||
47391 | m [3] SEQUENCE OF INTEGER, | |
47392 | n [4] SET OF BOOLEAN | |
47393 | } | |
47394 | END | |
47395 | ||
47396 | <STATIC> | |
47397 | ||
47398 | import from TempA all; | |
47399 | ||
47400 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
47401 | const BERPDU myValue := {g := 'FFFF'O} | |
47402 | ||
47403 | <TTCN_TC:EXEC> | |
47404 | ||
47405 | if (dec_BER_PDU('0402FFFF'O) == myValue) | |
47406 | ||
47407 | ||
47408 | {setverdict(pass);} else {setverdict(fail);} | |
47409 | ||
47410 | ||
47411 | <RESULT> | |
47412 | ||
47413 | Overall verdict: pass | |
47414 | ||
47415 | <END_TC> | |
47416 | ||
47417 | :exmp. | |
47418 | ||
47419 | .*---------------------------------------------------------------------* | |
47420 | :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - OBJECT IDENTIFIER | |
47421 | .*---------------------------------------------------------------------* | |
47422 | :xmp tab=0. | |
47423 | ||
47424 | <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - OBJECT IDENTIFIER> | |
47425 | ||
47426 | <STATIC:ASN> | |
47427 | ||
47428 | TempA | |
47429 | ||
47430 | DEFINITIONS ::= | |
47431 | BEGIN | |
47432 | BERPDU ::= CHOICE | |
47433 | { | |
47434 | a NULL, | |
47435 | b BOOLEAN, | |
47436 | c INTEGER, | |
47437 | d ENUMERATED {first ,second ,third}, | |
47438 | e REAL, | |
47439 | f BIT STRING, | |
47440 | g OCTET STRING, | |
47441 | ||
47442 | h OBJECT IDENTIFIER, | |
47443 | i IA5String, | |
47444 | j CHOICE {x1 [1] BOOLEAN, | |
47445 | y1 [2] OCTET STRING}, | |
47446 | ||
47447 | k SEQUENCE{x2 NULL, | |
47448 | y2 BOOLEAN}, | |
47449 | ||
47450 | l SET { x3 BIT STRING, | |
47451 | y3 REAL}, | |
47452 | ||
47453 | m [3] SEQUENCE OF INTEGER, | |
47454 | n [4] SET OF BOOLEAN | |
47455 | } | |
47456 | ||
47457 | myValue BERPDU ::= h : {itu-t(0) recommendation(0) a(2) b(3)} | |
47458 | ||
47459 | ||
47460 | END | |
47461 | ||
47462 | <STATIC> | |
47463 | ||
47464 | import from TempA all; | |
47465 | ||
47466 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
47467 | ||
47468 | <TTCN_TC:EXEC> | |
47469 | ||
47470 | if (dec_BER_PDU('0603000203'O) == myValue) | |
47471 | ||
47472 | ||
47473 | {setverdict(pass);} else {setverdict(fail);} | |
47474 | ||
47475 | ||
47476 | <RESULT> | |
47477 | ||
47478 | Overall verdict: pass | |
47479 | ||
47480 | <END_TC> | |
47481 | ||
47482 | :exmp. | |
47483 | ||
47484 | .*---------------------------------------------------------------------* | |
47485 | :h3. DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - IA5String | |
47486 | .*---------------------------------------------------------------------* | |
47487 | :xmp tab=0. | |
47488 | ||
47489 | <TC - DECODING OBJECT IDENTIFIER , CER+DER, CHOICE - IA5String> | |
47490 | ||
47491 | <STATIC:ASN> | |
47492 | ||
47493 | TempA | |
47494 | ||
47495 | DEFINITIONS ::= | |
47496 | BEGIN | |
47497 | BERPDU ::= CHOICE | |
47498 | { | |
47499 | a NULL, | |
47500 | b BOOLEAN, | |
47501 | c INTEGER, | |
47502 | d ENUMERATED {first ,second ,third}, | |
47503 | e REAL, | |
47504 | f BIT STRING, | |
47505 | g OCTET STRING, | |
47506 | ||
47507 | h OBJECT IDENTIFIER, | |
47508 | i IA5String, | |
47509 | j CHOICE {x1 [1] BOOLEAN, | |
47510 | y1 [2] OCTET STRING}, | |
47511 | ||
47512 | k SEQUENCE{x2 NULL, | |
47513 | y2 BOOLEAN}, | |
47514 | ||
47515 | l SET { x3 BIT STRING, | |
47516 | y3 REAL}, | |
47517 | ||
47518 | m [3] SEQUENCE OF INTEGER, | |
47519 | n [4] SET OF BOOLEAN | |
47520 | } | |
47521 | ||
47522 | ||
47523 | ||
47524 | END | |
47525 | ||
47526 | <STATIC> | |
47527 | ||
47528 | import from TempA all; | |
47529 | ||
47530 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
47531 | ||
47532 | const BERPDU myValue := {i := "ABC"} | |
47533 | ||
47534 | ||
47535 | <TTCN_TC:EXEC> | |
47536 | ||
47537 | if (dec_BER_PDU('1603414243'O) == myValue) | |
47538 | ||
47539 | ||
47540 | {setverdict(pass);} else {setverdict(fail);} | |
47541 | ||
47542 | ||
47543 | <RESULT> | |
47544 | ||
47545 | Overall verdict: pass | |
47546 | ||
47547 | <END_TC> | |
47548 | ||
47549 | :exmp. | |
47550 | ||
47551 | .*---------------------------------------------------------------------* | |
47552 | :h3. DECODING OBJECT IDENTIFIER ,DER, CHOICE - CHOICE | |
47553 | .*---------------------------------------------------------------------* | |
47554 | :xmp tab=0. | |
47555 | ||
47556 | <TC - DECODING OBJECT IDENTIFIER ,DER, CHOICE - CHOICE> | |
47557 | ||
47558 | <STATIC:ASN> | |
47559 | ||
47560 | TempA | |
47561 | ||
47562 | DEFINITIONS ::= | |
47563 | BEGIN | |
47564 | BERPDU ::= CHOICE | |
47565 | { | |
47566 | a NULL, | |
47567 | b BOOLEAN, | |
47568 | c INTEGER, | |
47569 | d ENUMERATED {first ,second ,third}, | |
47570 | e REAL, | |
47571 | f BIT STRING, | |
47572 | g OCTET STRING, | |
47573 | ||
47574 | h OBJECT IDENTIFIER, | |
47575 | i IA5String, | |
47576 | j CHOICE {x1 [1] BOOLEAN, | |
47577 | y1 [2] OCTET STRING}, | |
47578 | ||
47579 | k SEQUENCE{x2 NULL, | |
47580 | y2 BOOLEAN}, | |
47581 | ||
47582 | l SET { x3 BIT STRING, | |
47583 | y3 REAL}, | |
47584 | ||
47585 | m [3] SEQUENCE OF INTEGER, | |
47586 | n [4] SET OF BOOLEAN | |
47587 | } | |
47588 | ||
47589 | ||
47590 | ||
47591 | END | |
47592 | ||
47593 | <STATIC> | |
47594 | ||
47595 | import from TempA all; | |
47596 | ||
47597 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
47598 | ||
47599 | const BERPDU myValue := {j := {x1 := true } } | |
47600 | ||
47601 | ||
47602 | <TTCN_TC:EXEC> | |
47603 | ||
47604 | if (dec_BER_PDU('A1030101FF'O) == myValue) | |
47605 | ||
47606 | ||
47607 | {setverdict(pass);} else {setverdict(fail);} | |
47608 | ||
47609 | ||
47610 | <RESULT> | |
47611 | ||
47612 | Overall verdict: pass | |
47613 | ||
47614 | <END_TC> | |
47615 | ||
47616 | :exmp. | |
47617 | ||
47618 | .*---------------------------------------------------------------------* | |
47619 | :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - CHOICE | |
47620 | .*---------------------------------------------------------------------* | |
47621 | :xmp tab=0. | |
47622 | ||
47623 | <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - CHOICE> | |
47624 | ||
47625 | <STATIC:ASN> | |
47626 | ||
47627 | TempA | |
47628 | ||
47629 | DEFINITIONS ::= | |
47630 | BEGIN | |
47631 | BERPDU ::= CHOICE | |
47632 | { | |
47633 | a NULL, | |
47634 | b BOOLEAN, | |
47635 | c INTEGER, | |
47636 | d ENUMERATED {first ,second ,third}, | |
47637 | e REAL, | |
47638 | f BIT STRING, | |
47639 | g OCTET STRING, | |
47640 | ||
47641 | h OBJECT IDENTIFIER, | |
47642 | i IA5String, | |
47643 | j CHOICE {x1 [1] BOOLEAN, | |
47644 | y1 [2] OCTET STRING}, | |
47645 | ||
47646 | k SEQUENCE{x2 NULL, | |
47647 | y2 BOOLEAN}, | |
47648 | ||
47649 | l SET { x3 BIT STRING, | |
47650 | y3 REAL}, | |
47651 | ||
47652 | m [3] SEQUENCE OF INTEGER, | |
47653 | n [4] SET OF BOOLEAN | |
47654 | } | |
47655 | ||
47656 | ||
47657 | ||
47658 | END | |
47659 | ||
47660 | <STATIC> | |
47661 | ||
47662 | import from TempA all; | |
47663 | ||
47664 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
47665 | ||
47666 | const BERPDU myValue := {j := {x1 := true } } | |
47667 | ||
47668 | ||
47669 | <TTCN_TC:EXEC> | |
47670 | ||
47671 | if (dec_BER_PDU('A1800101FF0000'O) == myValue) | |
47672 | ||
47673 | ||
47674 | {setverdict(pass);} else {setverdict(fail);} | |
47675 | ||
47676 | ||
47677 | <RESULT> | |
47678 | ||
47679 | Overall verdict: pass | |
47680 | ||
47681 | <END_TC> | |
47682 | ||
47683 | :exmp. | |
47684 | ||
47685 | .*---------------------------------------------------------------------* | |
47686 | :h3. DECODING OBJECT IDENTIFIER , DER, CHOICE - SEQUENCE | |
47687 | .*---------------------------------------------------------------------* | |
47688 | :xmp tab=0. | |
47689 | ||
47690 | <TC - DECODING OBJECT IDENTIFIER , DER, CHOICE - SEQUENCE> | |
47691 | ||
47692 | <STATIC:ASN> | |
47693 | ||
47694 | TempA | |
47695 | ||
47696 | DEFINITIONS ::= | |
47697 | BEGIN | |
47698 | BERPDU ::= CHOICE | |
47699 | { | |
47700 | a NULL, | |
47701 | b BOOLEAN, | |
47702 | c INTEGER, | |
47703 | d ENUMERATED {first ,second ,third}, | |
47704 | e REAL, | |
47705 | f BIT STRING, | |
47706 | g OCTET STRING, | |
47707 | ||
47708 | h OBJECT IDENTIFIER, | |
47709 | i IA5String, | |
47710 | j CHOICE {x1 [1] BOOLEAN, | |
47711 | y1 [2] OCTET STRING}, | |
47712 | ||
47713 | k SEQUENCE{x2 NULL, | |
47714 | y2 BOOLEAN}, | |
47715 | ||
47716 | l SET { x3 BIT STRING, | |
47717 | y3 REAL}, | |
47718 | ||
47719 | m [3] SEQUENCE OF INTEGER, | |
47720 | n [4] SET OF BOOLEAN | |
47721 | } | |
47722 | ||
47723 | ||
47724 | ||
47725 | END | |
47726 | ||
47727 | <STATIC> | |
47728 | ||
47729 | import from TempA all; | |
47730 | ||
47731 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
47732 | ||
47733 | const BERPDU myValue := {k := {x2 := NULL, | |
47734 | ||
47735 | y2 := true } } | |
47736 | ||
47737 | ||
47738 | ||
47739 | <TTCN_TC:EXEC> | |
47740 | ||
47741 | if (dec_BER_PDU('300505000101FF'O) == myValue) | |
47742 | ||
47743 | ||
47744 | {setverdict(pass);} else {setverdict(fail);} | |
47745 | ||
47746 | ||
47747 | <RESULT> | |
47748 | ||
47749 | Overall verdict: pass | |
47750 | ||
47751 | <END_TC> | |
47752 | ||
47753 | :exmp. | |
47754 | ||
47755 | .*---------------------------------------------------------------------* | |
47756 | :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - SEQUENCE | |
47757 | .*---------------------------------------------------------------------* | |
47758 | :xmp tab=0. | |
47759 | ||
47760 | <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - SEQUENCE> | |
47761 | ||
47762 | <STATIC:ASN> | |
47763 | ||
47764 | TempA | |
47765 | ||
47766 | DEFINITIONS ::= | |
47767 | BEGIN | |
47768 | BERPDU ::= CHOICE | |
47769 | { | |
47770 | a NULL, | |
47771 | b BOOLEAN, | |
47772 | c INTEGER, | |
47773 | d ENUMERATED {first ,second ,third}, | |
47774 | e REAL, | |
47775 | f BIT STRING, | |
47776 | g OCTET STRING, | |
47777 | ||
47778 | h OBJECT IDENTIFIER, | |
47779 | i IA5String, | |
47780 | j CHOICE {x1 [1] BOOLEAN, | |
47781 | y1 [2] OCTET STRING}, | |
47782 | ||
47783 | k SEQUENCE{x2 NULL, | |
47784 | y2 BOOLEAN}, | |
47785 | ||
47786 | l SET { x3 BIT STRING, | |
47787 | y3 REAL}, | |
47788 | ||
47789 | m [3] SEQUENCE OF INTEGER, | |
47790 | n [4] SET OF BOOLEAN | |
47791 | } | |
47792 | ||
47793 | ||
47794 | ||
47795 | END | |
47796 | ||
47797 | <STATIC> | |
47798 | ||
47799 | import from TempA all; | |
47800 | ||
47801 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
47802 | ||
47803 | const BERPDU myValue := {k := {x2 := NULL, | |
47804 | ||
47805 | y2 := true } } | |
47806 | ||
47807 | ||
47808 | ||
47809 | <TTCN_TC:EXEC> | |
47810 | ||
47811 | if (dec_BER_PDU('308005000101FF0000'O) == myValue) | |
47812 | ||
47813 | ||
47814 | {setverdict(pass);} else {setverdict(fail);} | |
47815 | ||
47816 | ||
47817 | <RESULT> | |
47818 | ||
47819 | Overall verdict: pass | |
47820 | ||
47821 | <END_TC> | |
47822 | ||
47823 | :exmp. | |
47824 | ||
47825 | .*---------------------------------------------------------------------* | |
47826 | :h3. DECODING OBJECT IDENTIFIER , DER, CHOICE - SET | |
47827 | .*---------------------------------------------------------------------* | |
47828 | :xmp tab=0. | |
47829 | ||
47830 | <TC - DECODING OBJECT IDENTIFIER , DER, CHOICE - SET> | |
47831 | ||
47832 | <STATIC:ASN> | |
47833 | ||
47834 | TempA | |
47835 | ||
47836 | DEFINITIONS ::= | |
47837 | BEGIN | |
47838 | BERPDU ::= CHOICE | |
47839 | { | |
47840 | a NULL, | |
47841 | b BOOLEAN, | |
47842 | c INTEGER, | |
47843 | d ENUMERATED {first ,second ,third}, | |
47844 | e REAL, | |
47845 | f BIT STRING, | |
47846 | g OCTET STRING, | |
47847 | ||
47848 | h OBJECT IDENTIFIER, | |
47849 | i IA5String, | |
47850 | j CHOICE {x1 [1] BOOLEAN, | |
47851 | y1 [2] OCTET STRING}, | |
47852 | ||
47853 | k SEQUENCE{x2 NULL, | |
47854 | y2 BOOLEAN}, | |
47855 | ||
47856 | l SET { x3 BIT STRING, | |
47857 | y3 OCTET STRING}, | |
47858 | ||
47859 | m [3] SEQUENCE OF INTEGER, | |
47860 | n [4] SET OF BOOLEAN | |
47861 | } | |
47862 | ||
47863 | ||
47864 | ||
47865 | END | |
47866 | ||
47867 | <STATIC> | |
47868 | ||
47869 | import from TempA all; | |
47870 | ||
47871 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
47872 | ||
47873 | const BERPDU myValue := {l := {y3 := 'FFFF'O , | |
47874 | ||
47875 | x3 := '1'B } } | |
47876 | ||
47877 | ||
47878 | ||
47879 | ||
47880 | <TTCN_TC:EXEC> | |
47881 | ||
47882 | if (dec_BER_PDU('3108030207800402FFFF'O) == myValue) | |
47883 | ||
47884 | ||
47885 | {setverdict(pass);} else {setverdict(fail);} | |
47886 | ||
47887 | ||
47888 | <RESULT> | |
47889 | ||
47890 | Overall verdict: pass | |
47891 | ||
47892 | <END_TC> | |
47893 | ||
47894 | :exmp. | |
47895 | ||
47896 | .*---------------------------------------------------------------------* | |
47897 | :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - SET | |
47898 | .*---------------------------------------------------------------------* | |
47899 | :xmp tab=0. | |
47900 | ||
47901 | <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - SET> | |
47902 | ||
47903 | <STATIC:ASN> | |
47904 | ||
47905 | TempA | |
47906 | ||
47907 | DEFINITIONS ::= | |
47908 | BEGIN | |
47909 | BERPDU ::= CHOICE | |
47910 | { | |
47911 | a NULL, | |
47912 | b BOOLEAN, | |
47913 | c INTEGER, | |
47914 | d ENUMERATED {first ,second ,third}, | |
47915 | e REAL, | |
47916 | f BIT STRING, | |
47917 | g OCTET STRING, | |
47918 | ||
47919 | h OBJECT IDENTIFIER, | |
47920 | i IA5String, | |
47921 | j CHOICE {x1 [1] BOOLEAN, | |
47922 | y1 [2] OCTET STRING}, | |
47923 | ||
47924 | k SEQUENCE{x2 NULL, | |
47925 | y2 BOOLEAN}, | |
47926 | ||
47927 | l SET { x3 BIT STRING, | |
47928 | y3 OCTET STRING}, | |
47929 | ||
47930 | m [3] SEQUENCE OF INTEGER, | |
47931 | n [4] SET OF BOOLEAN | |
47932 | } | |
47933 | ||
47934 | ||
47935 | ||
47936 | END | |
47937 | ||
47938 | <STATIC> | |
47939 | ||
47940 | import from TempA all; | |
47941 | ||
47942 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
47943 | ||
47944 | const BERPDU myValue := {l := {y3 := 'FFFF'O , | |
47945 | ||
47946 | x3 := '1'B } } | |
47947 | ||
47948 | ||
47949 | ||
47950 | ||
47951 | <TTCN_TC:EXEC> | |
47952 | ||
47953 | if (dec_BER_PDU('3180030207800402FFFF0000'O) == myValue) | |
47954 | ||
47955 | ||
47956 | {setverdict(pass);} else {setverdict(fail);} | |
47957 | ||
47958 | ||
47959 | <RESULT> | |
47960 | ||
47961 | Overall verdict: pass | |
47962 | ||
47963 | <END_TC> | |
47964 | ||
47965 | :exmp. | |
47966 | ||
47967 | .*---------------------------------------------------------------------* | |
47968 | :h3. DECODING OBJECT IDENTIFIER , DER, CHOICE - SEQUENCE OF | |
47969 | .*---------------------------------------------------------------------* | |
47970 | :xmp tab=0. | |
47971 | ||
47972 | <TC - DECODING OBJECT IDENTIFIER , DER, CHOICE - SEQUENCE OF> | |
47973 | ||
47974 | <STATIC:ASN> | |
47975 | ||
47976 | TempA | |
47977 | ||
47978 | DEFINITIONS ::= | |
47979 | BEGIN | |
47980 | BERPDU ::= CHOICE | |
47981 | { | |
47982 | a NULL, | |
47983 | b BOOLEAN, | |
47984 | c INTEGER, | |
47985 | d ENUMERATED {first ,second ,third}, | |
47986 | e REAL, | |
47987 | f BIT STRING, | |
47988 | g OCTET STRING, | |
47989 | ||
47990 | h OBJECT IDENTIFIER, | |
47991 | i IA5String, | |
47992 | j CHOICE {x1 [1] BOOLEAN, | |
47993 | y1 [2] OCTET STRING}, | |
47994 | ||
47995 | k SEQUENCE{x2 NULL, | |
47996 | y2 BOOLEAN}, | |
47997 | ||
47998 | l SET { x3 BIT STRING, | |
47999 | y3 REAL}, | |
48000 | ||
48001 | m [3] SEQUENCE OF INTEGER, | |
48002 | n [4] SET OF BOOLEAN | |
48003 | } | |
48004 | ||
48005 | ||
48006 | ||
48007 | END | |
48008 | ||
48009 | <STATIC> | |
48010 | ||
48011 | import from TempA all; | |
48012 | ||
48013 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48014 | ||
48015 | const BERPDU myValue := {m := | |
48016 | { 1 ,2 } } | |
48017 | ||
48018 | ||
48019 | ||
48020 | <TTCN_TC:EXEC> | |
48021 | ||
48022 | if (dec_BER_PDU('A3083006020101020102'O) == myValue) | |
48023 | ||
48024 | ||
48025 | {setverdict(pass);} else {setverdict(fail);} | |
48026 | ||
48027 | ||
48028 | <RESULT> | |
48029 | ||
48030 | Overall verdict: pass | |
48031 | ||
48032 | <END_TC> | |
48033 | ||
48034 | :exmp. | |
48035 | ||
48036 | .*---------------------------------------------------------------------* | |
48037 | :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - SEQUENCE OF | |
48038 | .*---------------------------------------------------------------------* | |
48039 | :xmp tab=0. | |
48040 | ||
48041 | <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - SEQUENCE OF> | |
48042 | ||
48043 | <STATIC:ASN> | |
48044 | ||
48045 | TempA | |
48046 | ||
48047 | DEFINITIONS ::= | |
48048 | BEGIN | |
48049 | BERPDU ::= CHOICE | |
48050 | { | |
48051 | a NULL, | |
48052 | b BOOLEAN, | |
48053 | c INTEGER, | |
48054 | d ENUMERATED {first ,second ,third}, | |
48055 | e REAL, | |
48056 | f BIT STRING, | |
48057 | g OCTET STRING, | |
48058 | ||
48059 | h OBJECT IDENTIFIER, | |
48060 | i IA5String, | |
48061 | j CHOICE {x1 [1] BOOLEAN, | |
48062 | y1 [2] OCTET STRING}, | |
48063 | ||
48064 | k SEQUENCE{x2 NULL, | |
48065 | y2 BOOLEAN}, | |
48066 | ||
48067 | l SET { x3 BIT STRING, | |
48068 | y3 REAL}, | |
48069 | ||
48070 | m [3] SEQUENCE OF INTEGER, | |
48071 | n [4] SET OF BOOLEAN | |
48072 | } | |
48073 | ||
48074 | ||
48075 | ||
48076 | END | |
48077 | ||
48078 | <STATIC> | |
48079 | ||
48080 | import from TempA all; | |
48081 | ||
48082 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48083 | ||
48084 | const BERPDU myValue := {m := | |
48085 | { 1 ,2 } } | |
48086 | ||
48087 | ||
48088 | ||
48089 | <TTCN_TC:EXEC> | |
48090 | ||
48091 | if (dec_BER_PDU('A380308002010102010200000000'O) == myValue) | |
48092 | ||
48093 | ||
48094 | {setverdict(pass);} else {setverdict(fail);} | |
48095 | ||
48096 | ||
48097 | <RESULT> | |
48098 | ||
48099 | Overall verdict: pass | |
48100 | ||
48101 | <END_TC> | |
48102 | ||
48103 | :exmp. | |
48104 | ||
48105 | .*---------------------------------------------------------------------* | |
48106 | :h3. DECODING OBJECT IDENTIFIER , DER, CHOICE - SET OF | |
48107 | .*---------------------------------------------------------------------* | |
48108 | :xmp tab=0. | |
48109 | ||
48110 | <TC - DECODING OBJECT IDENTIFIER , DER, CHOICE - SET OF> | |
48111 | ||
48112 | <STATIC:ASN> | |
48113 | ||
48114 | TempA | |
48115 | ||
48116 | DEFINITIONS ::= | |
48117 | BEGIN | |
48118 | BERPDU ::= CHOICE | |
48119 | { | |
48120 | a NULL, | |
48121 | b BOOLEAN, | |
48122 | c INTEGER, | |
48123 | d ENUMERATED {first ,second ,third}, | |
48124 | e REAL, | |
48125 | f BIT STRING, | |
48126 | g OCTET STRING, | |
48127 | ||
48128 | h OBJECT IDENTIFIER, | |
48129 | i IA5String, | |
48130 | j CHOICE {x1 [1] BOOLEAN, | |
48131 | y1 [2] OCTET STRING}, | |
48132 | ||
48133 | k SEQUENCE{x2 NULL, | |
48134 | y2 BOOLEAN}, | |
48135 | ||
48136 | l SET { x3 BIT STRING, | |
48137 | y3 REAL}, | |
48138 | ||
48139 | m [3] SEQUENCE OF INTEGER, | |
48140 | n [4] SET OF BOOLEAN | |
48141 | } | |
48142 | ||
48143 | ||
48144 | ||
48145 | END | |
48146 | ||
48147 | <STATIC> | |
48148 | ||
48149 | import from TempA all; | |
48150 | ||
48151 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48152 | ||
48153 | const BERPDU myValue := {n := | |
48154 | { true, true } } | |
48155 | ||
48156 | ||
48157 | ||
48158 | <TTCN_TC:EXEC> | |
48159 | ||
48160 | if (dec_BER_PDU('A40831060101FF0101FF'O) == myValue) | |
48161 | ||
48162 | ||
48163 | {setverdict(pass);} else {setverdict(fail);} | |
48164 | ||
48165 | ||
48166 | <RESULT> | |
48167 | ||
48168 | Overall verdict: pass | |
48169 | ||
48170 | <END_TC> | |
48171 | ||
48172 | :exmp. | |
48173 | ||
48174 | .*---------------------------------------------------------------------* | |
48175 | :h3. DECODING OBJECT IDENTIFIER , CER, CHOICE - SET OF | |
48176 | .*---------------------------------------------------------------------* | |
48177 | :xmp tab=0. | |
48178 | ||
48179 | <TC - DECODING OBJECT IDENTIFIER , CER, CHOICE - SET OF> | |
48180 | ||
48181 | <STATIC:ASN> | |
48182 | ||
48183 | TempA | |
48184 | ||
48185 | DEFINITIONS ::= | |
48186 | BEGIN | |
48187 | BERPDU ::= CHOICE | |
48188 | { | |
48189 | a NULL, | |
48190 | b BOOLEAN, | |
48191 | c INTEGER, | |
48192 | d ENUMERATED {first ,second ,third}, | |
48193 | e REAL, | |
48194 | f BIT STRING, | |
48195 | g OCTET STRING, | |
48196 | ||
48197 | h OBJECT IDENTIFIER, | |
48198 | i IA5String, | |
48199 | j CHOICE {x1 [1] BOOLEAN, | |
48200 | y1 [2] OCTET STRING}, | |
48201 | ||
48202 | k SEQUENCE{x2 NULL, | |
48203 | y2 BOOLEAN}, | |
48204 | ||
48205 | l SET { x3 BIT STRING, | |
48206 | y3 REAL}, | |
48207 | ||
48208 | m [3] SEQUENCE OF INTEGER, | |
48209 | n [4] SET OF BOOLEAN | |
48210 | } | |
48211 | ||
48212 | ||
48213 | ||
48214 | END | |
48215 | ||
48216 | <STATIC> | |
48217 | ||
48218 | import from TempA all; | |
48219 | ||
48220 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48221 | ||
48222 | const BERPDU myValue := {n := | |
48223 | { true, true } } | |
48224 | ||
48225 | ||
48226 | ||
48227 | <TTCN_TC:EXEC> | |
48228 | ||
48229 | if (dec_BER_PDU('A48031800101FF0101FF00000000'O) == myValue) | |
48230 | ||
48231 | ||
48232 | {setverdict(pass);} else {setverdict(fail);} | |
48233 | ||
48234 | ||
48235 | <RESULT> | |
48236 | ||
48237 | Overall verdict: pass | |
48238 | ||
48239 | <END_TC> | |
48240 | ||
48241 | :exmp. | |
48242 | ||
48243 | .*---------------------------------------------------------------------* | |
48244 | :h3.CER + DER decoding of CHOICE - Default IMPLICIT TAGS, CHOICE untagged | |
48245 | .*---------------------------------------------------------------------* | |
48246 | :xmp tab=0. | |
48247 | ||
48248 | <TC - CER + DER decoding of CHOICE - Default IMPLICIT TAGS, CHOICE untagged> | |
48249 | ||
48250 | <STATIC:ASN> | |
48251 | ||
48252 | TempA | |
48253 | ||
48254 | DEFINITIONS | |
48255 | ||
48256 | IMPLICIT TAGS | |
48257 | ||
48258 | ::= | |
48259 | ||
48260 | BEGIN | |
48261 | BERPDU ::= CHOICE | |
48262 | { | |
48263 | b BOOLEAN, | |
48264 | c INTEGER | |
48265 | } | |
48266 | ||
48267 | ||
48268 | ||
48269 | END | |
48270 | ||
48271 | <STATIC> | |
48272 | ||
48273 | import from TempA all; | |
48274 | ||
48275 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48276 | ||
48277 | const BERPDU myValue := {b := true } | |
48278 | ||
48279 | ||
48280 | ||
48281 | <TTCN_TC:EXEC> | |
48282 | ||
48283 | if (dec_BER_PDU('0101FF'O) == myValue) | |
48284 | ||
48285 | ||
48286 | {setverdict(pass);} else {setverdict(fail);} | |
48287 | ||
48288 | ||
48289 | <RESULT> | |
48290 | ||
48291 | Overall verdict: pass | |
48292 | ||
48293 | <END_TC> | |
48294 | ||
48295 | :exmp. | |
48296 | ||
48297 | .*---------------------------------------------------------------------* | |
48298 | :h3.CER + DER decoding of CHOICE - Default EXPLICIT TAGS, CHOICE untagged | |
48299 | .*---------------------------------------------------------------------* | |
48300 | :xmp tab=0. | |
48301 | ||
48302 | <TC - CER + DER decoding of CHOICE - Default EXPLICIT TAGS, CHOICE untagged> | |
48303 | ||
48304 | <STATIC:ASN> | |
48305 | ||
48306 | TempA | |
48307 | ||
48308 | DEFINITIONS | |
48309 | ||
48310 | EXPLICIT TAGS | |
48311 | ||
48312 | ||
48313 | ::= | |
48314 | ||
48315 | BEGIN | |
48316 | BERPDU ::= CHOICE | |
48317 | { | |
48318 | b BOOLEAN, | |
48319 | c INTEGER | |
48320 | } | |
48321 | ||
48322 | ||
48323 | ||
48324 | END | |
48325 | ||
48326 | <STATIC> | |
48327 | ||
48328 | import from TempA all; | |
48329 | ||
48330 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48331 | ||
48332 | const BERPDU myValue := {b := true } | |
48333 | ||
48334 | ||
48335 | ||
48336 | <TTCN_TC:EXEC> | |
48337 | ||
48338 | if (dec_BER_PDU('0101FF'O) == myValue) | |
48339 | ||
48340 | ||
48341 | {setverdict(pass);} else {setverdict(fail);} | |
48342 | ||
48343 | ||
48344 | <RESULT> | |
48345 | ||
48346 | Overall verdict: pass | |
48347 | ||
48348 | <END_TC> | |
48349 | ||
48350 | :exmp. | |
48351 | ||
48352 | .*---------------------------------------------------------------------* | |
48353 | :h3.CER + DER decoding of CHOICE - No Default TAGS, CHOICE untagged | |
48354 | .*---------------------------------------------------------------------* | |
48355 | :xmp tab=0. | |
48356 | ||
48357 | <TC - CER + DER decoding of CHOICE - No Default TAGS, CHOICE untagged> | |
48358 | ||
48359 | <STATIC:ASN> | |
48360 | ||
48361 | TempA | |
48362 | ||
48363 | DEFINITIONS | |
48364 | ||
48365 | ||
48366 | ||
48367 | ||
48368 | ::= | |
48369 | ||
48370 | BEGIN | |
48371 | BERPDU ::= CHOICE | |
48372 | { | |
48373 | b BOOLEAN, | |
48374 | c INTEGER | |
48375 | } | |
48376 | ||
48377 | ||
48378 | ||
48379 | END | |
48380 | ||
48381 | <STATIC> | |
48382 | ||
48383 | import from TempA all; | |
48384 | ||
48385 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48386 | ||
48387 | const BERPDU myValue := {b := true } | |
48388 | ||
48389 | ||
48390 | ||
48391 | <TTCN_TC:EXEC> | |
48392 | ||
48393 | if (dec_BER_PDU('0101FF'O) == myValue) | |
48394 | ||
48395 | ||
48396 | {setverdict(pass);} else {setverdict(fail);} | |
48397 | ||
48398 | ||
48399 | <RESULT> | |
48400 | ||
48401 | Overall verdict: pass | |
48402 | ||
48403 | <END_TC> | |
48404 | ||
48405 | :exmp. | |
48406 | ||
48407 | .*---------------------------------------------------------------------* | |
48408 | :h3.CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, CHOICE untagged | |
48409 | .*---------------------------------------------------------------------* | |
48410 | :xmp tab=0. | |
48411 | ||
48412 | <TC - CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, CHOICE untagged> | |
48413 | ||
48414 | <STATIC:ASN> | |
48415 | ||
48416 | TempA | |
48417 | ||
48418 | DEFINITIONS | |
48419 | ||
48420 | ||
48421 | AUTOMATIC TAGS | |
48422 | ||
48423 | ::= | |
48424 | ||
48425 | BEGIN | |
48426 | BERPDU ::= CHOICE | |
48427 | { | |
48428 | b BOOLEAN, | |
48429 | c INTEGER | |
48430 | } | |
48431 | ||
48432 | ||
48433 | ||
48434 | END | |
48435 | ||
48436 | <STATIC> | |
48437 | ||
48438 | import from TempA all; | |
48439 | ||
48440 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48441 | ||
48442 | const BERPDU myValue := {b := true } | |
48443 | ||
48444 | ||
48445 | ||
48446 | <TTCN_TC:EXEC> | |
48447 | ||
48448 | if (dec_BER_PDU('8001FF'O) == myValue) | |
48449 | ||
48450 | ||
48451 | {setverdict(pass);} else {setverdict(fail);} | |
48452 | ||
48453 | ||
48454 | <RESULT> | |
48455 | ||
48456 | Overall verdict: pass | |
48457 | ||
48458 | <END_TC> | |
48459 | ||
48460 | :exmp. | |
48461 | ||
48462 | .*---------------------------------------------------------------------* | |
48463 | :h3.CER + DER decoding of CHOICE - Default IMPLICIT TAGS, number-tagged CHOICE | |
48464 | .*---------------------------------------------------------------------* | |
48465 | :xmp tab=0. | |
48466 | ||
48467 | <TC - CER + DER decoding of CHOICE - Default IMPLICIT TAGS, number-tagged CHOICE> | |
48468 | ||
48469 | <STATIC:ASN> | |
48470 | ||
48471 | TempA | |
48472 | ||
48473 | DEFINITIONS | |
48474 | ||
48475 | IMPLICIT TAGS | |
48476 | ||
48477 | ||
48478 | ||
48479 | ||
48480 | ::= | |
48481 | ||
48482 | BEGIN | |
48483 | BERPDU ::= CHOICE | |
48484 | { | |
48485 | b [3] BOOLEAN, | |
48486 | c [6] INTEGER | |
48487 | } | |
48488 | ||
48489 | ||
48490 | END | |
48491 | ||
48492 | ||
48493 | ||
48494 | <STATIC> | |
48495 | ||
48496 | import from TempA all; | |
48497 | ||
48498 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48499 | ||
48500 | const BERPDU myValue := {b := true } | |
48501 | ||
48502 | ||
48503 | ||
48504 | <TTCN_TC:EXEC> | |
48505 | ||
48506 | if (dec_BER_PDU('8301FF'O) == myValue) | |
48507 | ||
48508 | ||
48509 | {setverdict(pass);} else {setverdict(fail);} | |
48510 | ||
48511 | ||
48512 | <RESULT> | |
48513 | ||
48514 | Overall verdict: pass | |
48515 | ||
48516 | <END_TC> | |
48517 | ||
48518 | :exmp. | |
48519 | ||
48520 | .*---------------------------------------------------------------------* | |
48521 | :h3. DER decoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE | |
48522 | .*---------------------------------------------------------------------* | |
48523 | :xmp tab=0. | |
48524 | ||
48525 | <TC - DER decoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE> | |
48526 | ||
48527 | <STATIC:ASN> | |
48528 | ||
48529 | TempA | |
48530 | ||
48531 | DEFINITIONS | |
48532 | ||
48533 | EXPLICIT TAGS | |
48534 | ||
48535 | ||
48536 | ||
48537 | ||
48538 | ::= | |
48539 | ||
48540 | BEGIN | |
48541 | BERPDU ::= CHOICE | |
48542 | { | |
48543 | b [3] BOOLEAN, | |
48544 | c [6] INTEGER | |
48545 | } | |
48546 | ||
48547 | ||
48548 | END | |
48549 | ||
48550 | ||
48551 | ||
48552 | <STATIC> | |
48553 | ||
48554 | import from TempA all; | |
48555 | ||
48556 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48557 | ||
48558 | const BERPDU myValue := {b := true } | |
48559 | ||
48560 | ||
48561 | ||
48562 | <TTCN_TC:EXEC> | |
48563 | ||
48564 | if (dec_BER_PDU('A3030101FF'O) == myValue) | |
48565 | ||
48566 | ||
48567 | {setverdict(pass);} else {setverdict(fail);} | |
48568 | ||
48569 | ||
48570 | <RESULT> | |
48571 | ||
48572 | Overall verdict: pass | |
48573 | ||
48574 | <END_TC> | |
48575 | ||
48576 | :exmp. | |
48577 | ||
48578 | .*---------------------------------------------------------------------* | |
48579 | :h3. CER decoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE | |
48580 | .*---------------------------------------------------------------------* | |
48581 | :xmp tab=0. | |
48582 | ||
48583 | <TC - CER decoding of CHOICE - Default EXPLICIT TAGS, number-tagged CHOICE> | |
48584 | ||
48585 | <STATIC:ASN> | |
48586 | ||
48587 | TempA | |
48588 | ||
48589 | DEFINITIONS | |
48590 | ||
48591 | EXPLICIT TAGS | |
48592 | ||
48593 | ||
48594 | ::= | |
48595 | ||
48596 | BEGIN | |
48597 | BERPDU ::= CHOICE | |
48598 | { | |
48599 | b [3] BOOLEAN, | |
48600 | c [6] INTEGER | |
48601 | } | |
48602 | ||
48603 | ||
48604 | END | |
48605 | ||
48606 | ||
48607 | ||
48608 | <STATIC> | |
48609 | ||
48610 | import from TempA all; | |
48611 | ||
48612 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48613 | ||
48614 | const BERPDU myValue := {b := true } | |
48615 | ||
48616 | ||
48617 | ||
48618 | <TTCN_TC:EXEC> | |
48619 | ||
48620 | if (dec_BER_PDU('A3800101FF0000'O) == myValue) | |
48621 | ||
48622 | ||
48623 | {setverdict(pass);} else {setverdict(fail);} | |
48624 | ||
48625 | ||
48626 | <RESULT> | |
48627 | ||
48628 | Overall verdict: pass | |
48629 | ||
48630 | <END_TC> | |
48631 | ||
48632 | :exmp. | |
48633 | ||
48634 | .*---------------------------------------------------------------------* | |
48635 | :h3. DER decoding of CHOICE - No Default TAGS, number-tagged CHOICE | |
48636 | .*---------------------------------------------------------------------* | |
48637 | :xmp tab=0. | |
48638 | ||
48639 | <TC - DER decoding of CHOICE - No Default TAGS, number-tagged CHOICE> | |
48640 | ||
48641 | <STATIC:ASN> | |
48642 | ||
48643 | TempA | |
48644 | ||
48645 | DEFINITIONS | |
48646 | ||
48647 | ||
48648 | ||
48649 | ||
48650 | ::= | |
48651 | ||
48652 | BEGIN | |
48653 | BERPDU ::= CHOICE | |
48654 | { | |
48655 | b [3] BOOLEAN, | |
48656 | c [6] INTEGER | |
48657 | } | |
48658 | ||
48659 | ||
48660 | END | |
48661 | ||
48662 | ||
48663 | <STATIC> | |
48664 | ||
48665 | import from TempA all; | |
48666 | ||
48667 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48668 | ||
48669 | const BERPDU myValue := {b := true } | |
48670 | ||
48671 | ||
48672 | ||
48673 | <TTCN_TC:EXEC> | |
48674 | ||
48675 | if (dec_BER_PDU('A3030101FF'O) == myValue) | |
48676 | ||
48677 | ||
48678 | {setverdict(pass);} else {setverdict(fail);} | |
48679 | ||
48680 | ||
48681 | <RESULT> | |
48682 | ||
48683 | Overall verdict: pass | |
48684 | ||
48685 | <END_TC> | |
48686 | ||
48687 | :exmp. | |
48688 | ||
48689 | .*---------------------------------------------------------------------* | |
48690 | :h3. CER decoding of CHOICE - No Default TAGS, number-tagged CHOICE | |
48691 | .*---------------------------------------------------------------------* | |
48692 | :xmp tab=0. | |
48693 | ||
48694 | <TC - CER decoding of CHOICE - No Default TAGS, number-tagged CHOICE> | |
48695 | ||
48696 | <STATIC:ASN> | |
48697 | ||
48698 | TempA | |
48699 | ||
48700 | DEFINITIONS | |
48701 | ||
48702 | ||
48703 | ||
48704 | ||
48705 | ::= | |
48706 | ||
48707 | BEGIN | |
48708 | BERPDU ::= CHOICE | |
48709 | { | |
48710 | b [3] BOOLEAN, | |
48711 | c [6] INTEGER | |
48712 | } | |
48713 | ||
48714 | ||
48715 | END | |
48716 | ||
48717 | ||
48718 | ||
48719 | <STATIC> | |
48720 | ||
48721 | import from TempA all; | |
48722 | ||
48723 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48724 | ||
48725 | const BERPDU myValue := {b := true } | |
48726 | ||
48727 | ||
48728 | ||
48729 | <TTCN_TC:EXEC> | |
48730 | ||
48731 | if (dec_BER_PDU('A3800101FF0000'O) == myValue) | |
48732 | ||
48733 | ||
48734 | {setverdict(pass);} else {setverdict(fail);} | |
48735 | ||
48736 | ||
48737 | <RESULT> | |
48738 | ||
48739 | Overall verdict: pass | |
48740 | ||
48741 | <END_TC> | |
48742 | ||
48743 | :exmp. | |
48744 | ||
48745 | .*---------------------------------------------------------------------* | |
48746 | :h3. CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE | |
48747 | .*---------------------------------------------------------------------* | |
48748 | :xmp tab=0. | |
48749 | ||
48750 | <TC - CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE> | |
48751 | ||
48752 | <STATIC:ASN> | |
48753 | ||
48754 | TempA | |
48755 | ||
48756 | DEFINITIONS | |
48757 | ||
48758 | ||
48759 | AUTOMATIC TAGS | |
48760 | ||
48761 | ::= | |
48762 | ||
48763 | BEGIN | |
48764 | BERPDU ::= CHOICE | |
48765 | { | |
48766 | b [3] BOOLEAN, | |
48767 | c [6] INTEGER | |
48768 | } | |
48769 | ||
48770 | ||
48771 | ||
48772 | END | |
48773 | ||
48774 | ||
48775 | ||
48776 | <STATIC> | |
48777 | ||
48778 | import from TempA all; | |
48779 | ||
48780 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48781 | ||
48782 | const BERPDU myValue := {b := true } | |
48783 | ||
48784 | ||
48785 | ||
48786 | <TTCN_TC:EXEC> | |
48787 | ||
48788 | if (dec_BER_PDU('8301FF'O) == myValue) | |
48789 | ||
48790 | ||
48791 | {setverdict(pass);} else {setverdict(fail);} | |
48792 | ||
48793 | ||
48794 | <RESULT> | |
48795 | ||
48796 | Overall verdict: pass | |
48797 | ||
48798 | <END_TC> | |
48799 | ||
48800 | :exmp. | |
48801 | ||
48802 | .*---------------------------------------------------------------------* | |
48803 | :h3. CER + DER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE | |
48804 | .*---------------------------------------------------------------------* | |
48805 | :xmp tab=0. | |
48806 | ||
48807 | <TC - CER + DER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE> | |
48808 | ||
48809 | <STATIC:ASN> | |
48810 | ||
48811 | TempA | |
48812 | ||
48813 | DEFINITIONS | |
48814 | ||
48815 | ||
48816 | IMPLICIT TAGS | |
48817 | ||
48818 | ::= | |
48819 | ||
48820 | BEGIN | |
48821 | BERPDU ::= CHOICE | |
48822 | { | |
48823 | b [3] IMPLICIT BOOLEAN, | |
48824 | c [6] INTEGER | |
48825 | } | |
48826 | ||
48827 | ||
48828 | END | |
48829 | ||
48830 | ||
48831 | ||
48832 | <STATIC> | |
48833 | ||
48834 | import from TempA all; | |
48835 | ||
48836 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48837 | ||
48838 | const BERPDU myValue := {b := true } | |
48839 | ||
48840 | ||
48841 | ||
48842 | <TTCN_TC:EXEC> | |
48843 | ||
48844 | if (dec_BER_PDU('8301FF'O) == myValue) | |
48845 | ||
48846 | ||
48847 | {setverdict(pass);} else {setverdict(fail);} | |
48848 | ||
48849 | ||
48850 | <RESULT> | |
48851 | ||
48852 | Overall verdict: pass | |
48853 | ||
48854 | <END_TC> | |
48855 | ||
48856 | :exmp. | |
48857 | ||
48858 | .*---------------------------------------------------------------------* | |
48859 | :h3. CER + DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE | |
48860 | .*---------------------------------------------------------------------* | |
48861 | :xmp tab=0. | |
48862 | ||
48863 | <TC - CER + DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE> | |
48864 | ||
48865 | <STATIC:ASN> | |
48866 | ||
48867 | TempA | |
48868 | ||
48869 | DEFINITIONS | |
48870 | ||
48871 | ||
48872 | EXPLICIT TAGS | |
48873 | ||
48874 | ::= | |
48875 | ||
48876 | BEGIN | |
48877 | BERPDU ::= CHOICE | |
48878 | { | |
48879 | b [3] IMPLICIT BOOLEAN, | |
48880 | c [6] INTEGER | |
48881 | } | |
48882 | ||
48883 | ||
48884 | END | |
48885 | ||
48886 | ||
48887 | ||
48888 | <STATIC> | |
48889 | ||
48890 | import from TempA all; | |
48891 | ||
48892 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48893 | ||
48894 | const BERPDU myValue := {b := true } | |
48895 | ||
48896 | ||
48897 | ||
48898 | <TTCN_TC:EXEC> | |
48899 | ||
48900 | if (dec_BER_PDU('8301FF'O) == myValue) | |
48901 | ||
48902 | ||
48903 | {setverdict(pass);} else {setverdict(fail);} | |
48904 | ||
48905 | ||
48906 | <RESULT> | |
48907 | ||
48908 | Overall verdict: pass | |
48909 | ||
48910 | <END_TC> | |
48911 | ||
48912 | :exmp. | |
48913 | ||
48914 | .*---------------------------------------------------------------------* | |
48915 | :h3. CER + DER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE | |
48916 | .*---------------------------------------------------------------------* | |
48917 | :xmp tab=0. | |
48918 | ||
48919 | <TC - CER + DER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE> | |
48920 | ||
48921 | <STATIC:ASN> | |
48922 | ||
48923 | TempA | |
48924 | ||
48925 | DEFINITIONS | |
48926 | ||
48927 | ||
48928 | ||
48929 | ::= | |
48930 | ||
48931 | BEGIN | |
48932 | BERPDU ::= CHOICE | |
48933 | { | |
48934 | b [3] IMPLICIT BOOLEAN, | |
48935 | c [6] INTEGER | |
48936 | } | |
48937 | ||
48938 | ||
48939 | END | |
48940 | ||
48941 | ||
48942 | ||
48943 | <STATIC> | |
48944 | ||
48945 | import from TempA all; | |
48946 | ||
48947 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
48948 | ||
48949 | const BERPDU myValue := {b := true } | |
48950 | ||
48951 | ||
48952 | ||
48953 | <TTCN_TC:EXEC> | |
48954 | ||
48955 | if (dec_BER_PDU('8301FF'O) == myValue) | |
48956 | ||
48957 | ||
48958 | {setverdict(pass);} else {setverdict(fail);} | |
48959 | ||
48960 | ||
48961 | <RESULT> | |
48962 | ||
48963 | Overall verdict: pass | |
48964 | ||
48965 | <END_TC> | |
48966 | ||
48967 | :exmp. | |
48968 | ||
48969 | .*---------------------------------------------------------------------* | |
48970 | :h3. CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE | |
48971 | .*---------------------------------------------------------------------* | |
48972 | :xmp tab=0. | |
48973 | ||
48974 | <TC - CER + DER decoding of CHOICE - Default AUTOMATIC TAGS, number-tagged CHOICE> | |
48975 | ||
48976 | <STATIC:ASN> | |
48977 | ||
48978 | TempA | |
48979 | ||
48980 | DEFINITIONS | |
48981 | ||
48982 | AUTOMATIC TAGS | |
48983 | ||
48984 | ||
48985 | ::= | |
48986 | ||
48987 | BEGIN | |
48988 | ||
48989 | ||
48990 | BERPDU ::= CHOICE | |
48991 | { | |
48992 | b [3] IMPLICIT BOOLEAN, | |
48993 | c [6] INTEGER | |
48994 | } | |
48995 | ||
48996 | ||
48997 | ||
48998 | ||
48999 | ||
49000 | END | |
49001 | ||
49002 | <STATIC> | |
49003 | ||
49004 | import from TempA all; | |
49005 | ||
49006 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49007 | ||
49008 | const BERPDU myValue := {b := true } | |
49009 | ||
49010 | ||
49011 | ||
49012 | <TTCN_TC:EXEC> | |
49013 | ||
49014 | if (dec_BER_PDU('8301FF'O) == myValue) | |
49015 | ||
49016 | ||
49017 | {setverdict(pass);} else {setverdict(fail);} | |
49018 | ||
49019 | ||
49020 | <RESULT> | |
49021 | ||
49022 | Overall verdict: pass | |
49023 | ||
49024 | <END_TC> | |
49025 | ||
49026 | :exmp. | |
49027 | ||
49028 | .*---------------------------------------------------------------------* | |
49029 | :h3. DER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE | |
49030 | .*---------------------------------------------------------------------* | |
49031 | :xmp tab=0. | |
49032 | ||
49033 | <TC - DER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE> | |
49034 | ||
49035 | <STATIC:ASN> | |
49036 | ||
49037 | TempA | |
49038 | ||
49039 | DEFINITIONS | |
49040 | ||
49041 | IMPLICIT TAGS | |
49042 | ||
49043 | ||
49044 | ||
49045 | ::= | |
49046 | ||
49047 | BEGIN | |
49048 | ||
49049 | ||
49050 | BERPDU ::= CHOICE | |
49051 | { | |
49052 | b [3] EXPLICIT BOOLEAN, | |
49053 | c [6] INTEGER | |
49054 | } | |
49055 | ||
49056 | ||
49057 | ||
49058 | ||
49059 | END | |
49060 | ||
49061 | <STATIC> | |
49062 | ||
49063 | import from TempA all; | |
49064 | ||
49065 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49066 | ||
49067 | const BERPDU myValue := {b := true } | |
49068 | ||
49069 | ||
49070 | ||
49071 | <TTCN_TC:EXEC> | |
49072 | ||
49073 | if (dec_BER_PDU('A3030101FF'O) == myValue) | |
49074 | ||
49075 | ||
49076 | {setverdict(pass);} else {setverdict(fail);} | |
49077 | ||
49078 | ||
49079 | <RESULT> | |
49080 | ||
49081 | Overall verdict: pass | |
49082 | ||
49083 | <END_TC> | |
49084 | ||
49085 | :exmp. | |
49086 | ||
49087 | .*---------------------------------------------------------------------* | |
49088 | :h3. CER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE | |
49089 | .*---------------------------------------------------------------------* | |
49090 | :xmp tab=0. | |
49091 | ||
49092 | <TC - CER decoding of CHOICE - Default IMPLICIT TAGS, fully-tagged CHOICE> | |
49093 | ||
49094 | <STATIC:ASN> | |
49095 | ||
49096 | TempA | |
49097 | ||
49098 | DEFINITIONS | |
49099 | ||
49100 | IMPLICIT TAGS | |
49101 | ||
49102 | ||
49103 | ||
49104 | ::= | |
49105 | ||
49106 | BEGIN | |
49107 | ||
49108 | ||
49109 | BERPDU ::= CHOICE | |
49110 | { | |
49111 | b [3] EXPLICIT BOOLEAN, | |
49112 | c [6] INTEGER | |
49113 | } | |
49114 | ||
49115 | ||
49116 | ||
49117 | ||
49118 | END | |
49119 | ||
49120 | <STATIC> | |
49121 | ||
49122 | import from TempA all; | |
49123 | ||
49124 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49125 | ||
49126 | const BERPDU myValue := {b := true } | |
49127 | ||
49128 | ||
49129 | ||
49130 | <TTCN_TC:EXEC> | |
49131 | ||
49132 | if (dec_BER_PDU('A3800101FF0000'O) == myValue) | |
49133 | ||
49134 | ||
49135 | {setverdict(pass);} else {setverdict(fail);} | |
49136 | ||
49137 | ||
49138 | <RESULT> | |
49139 | ||
49140 | Overall verdict: pass | |
49141 | ||
49142 | <END_TC> | |
49143 | ||
49144 | :exmp. | |
49145 | ||
49146 | .*---------------------------------------------------------------------* | |
49147 | :h3. DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE | |
49148 | .*---------------------------------------------------------------------* | |
49149 | :xmp tab=0. | |
49150 | ||
49151 | <TC - DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE> | |
49152 | ||
49153 | <STATIC:ASN> | |
49154 | ||
49155 | TempA | |
49156 | ||
49157 | DEFINITIONS | |
49158 | ||
49159 | EXPLICIT TAGS | |
49160 | ||
49161 | ||
49162 | ||
49163 | ::= | |
49164 | ||
49165 | BEGIN | |
49166 | ||
49167 | ||
49168 | BERPDU ::= CHOICE | |
49169 | { | |
49170 | b [3] EXPLICIT BOOLEAN, | |
49171 | c [6] INTEGER | |
49172 | } | |
49173 | ||
49174 | ||
49175 | ||
49176 | ||
49177 | END | |
49178 | ||
49179 | <STATIC> | |
49180 | ||
49181 | import from TempA all; | |
49182 | ||
49183 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49184 | ||
49185 | const BERPDU myValue := {b := true } | |
49186 | ||
49187 | ||
49188 | ||
49189 | <TTCN_TC:EXEC> | |
49190 | ||
49191 | if (dec_BER_PDU('A3030101FF'O) == myValue) | |
49192 | ||
49193 | ||
49194 | {setverdict(pass);} else {setverdict(fail);} | |
49195 | ||
49196 | ||
49197 | <RESULT> | |
49198 | ||
49199 | Overall verdict: pass | |
49200 | ||
49201 | <END_TC> | |
49202 | ||
49203 | :exmp. | |
49204 | ||
49205 | .*---------------------------------------------------------------------* | |
49206 | :h3. CER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE | |
49207 | .*---------------------------------------------------------------------* | |
49208 | :xmp tab=0. | |
49209 | ||
49210 | <TC - CER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE> | |
49211 | ||
49212 | <STATIC:ASN> | |
49213 | ||
49214 | TempA | |
49215 | ||
49216 | DEFINITIONS | |
49217 | ||
49218 | EXPLICIT TAGS | |
49219 | ||
49220 | ||
49221 | ||
49222 | ::= | |
49223 | ||
49224 | BEGIN | |
49225 | ||
49226 | ||
49227 | BERPDU ::= CHOICE | |
49228 | { | |
49229 | b [3] EXPLICIT BOOLEAN, | |
49230 | c [6] INTEGER | |
49231 | } | |
49232 | ||
49233 | ||
49234 | ||
49235 | ||
49236 | END | |
49237 | ||
49238 | <STATIC> | |
49239 | ||
49240 | import from TempA all; | |
49241 | ||
49242 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49243 | ||
49244 | const BERPDU myValue := {b := true } | |
49245 | ||
49246 | ||
49247 | ||
49248 | <TTCN_TC:EXEC> | |
49249 | ||
49250 | if (dec_BER_PDU('A3800101FF0000'O) == myValue) | |
49251 | ||
49252 | ||
49253 | {setverdict(pass);} else {setverdict(fail);} | |
49254 | ||
49255 | ||
49256 | <RESULT> | |
49257 | ||
49258 | Overall verdict: pass | |
49259 | ||
49260 | <END_TC> | |
49261 | ||
49262 | :exmp. | |
49263 | ||
49264 | .*---------------------------------------------------------------------* | |
49265 | :h3. DER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE | |
49266 | .*---------------------------------------------------------------------* | |
49267 | :xmp tab=0. | |
49268 | ||
49269 | <TC - DER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE> | |
49270 | ||
49271 | <STATIC:ASN> | |
49272 | ||
49273 | TempA | |
49274 | ||
49275 | DEFINITIONS | |
49276 | ||
49277 | ||
49278 | ||
49279 | ||
49280 | ::= | |
49281 | ||
49282 | BEGIN | |
49283 | ||
49284 | ||
49285 | BERPDU ::= CHOICE | |
49286 | { | |
49287 | b [3] EXPLICIT BOOLEAN, | |
49288 | c [6] INTEGER | |
49289 | } | |
49290 | ||
49291 | ||
49292 | ||
49293 | ||
49294 | END | |
49295 | ||
49296 | <STATIC> | |
49297 | ||
49298 | import from TempA all; | |
49299 | ||
49300 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49301 | ||
49302 | const BERPDU myValue := {b := true } | |
49303 | ||
49304 | ||
49305 | ||
49306 | <TTCN_TC:EXEC> | |
49307 | ||
49308 | if (dec_BER_PDU('A3030101FF'O) == myValue) | |
49309 | ||
49310 | ||
49311 | {setverdict(pass);} else {setverdict(fail);} | |
49312 | ||
49313 | ||
49314 | <RESULT> | |
49315 | ||
49316 | Overall verdict: pass | |
49317 | ||
49318 | <END_TC> | |
49319 | ||
49320 | :exmp. | |
49321 | ||
49322 | .*---------------------------------------------------------------------* | |
49323 | :h3. CER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE | |
49324 | .*---------------------------------------------------------------------* | |
49325 | :xmp tab=0. | |
49326 | ||
49327 | <TC - CER decoding of CHOICE - No Default TAGS, fully-tagged CHOICE> | |
49328 | ||
49329 | <STATIC:ASN> | |
49330 | ||
49331 | TempA | |
49332 | ||
49333 | DEFINITIONS | |
49334 | ||
49335 | ||
49336 | ||
49337 | ||
49338 | ::= | |
49339 | ||
49340 | BEGIN | |
49341 | ||
49342 | ||
49343 | BERPDU ::= CHOICE | |
49344 | { | |
49345 | b [3] EXPLICIT BOOLEAN, | |
49346 | c [6] INTEGER | |
49347 | } | |
49348 | ||
49349 | ||
49350 | ||
49351 | ||
49352 | END | |
49353 | ||
49354 | <STATIC> | |
49355 | ||
49356 | import from TempA all; | |
49357 | ||
49358 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49359 | ||
49360 | const BERPDU myValue := {b := true } | |
49361 | ||
49362 | ||
49363 | ||
49364 | <TTCN_TC:EXEC> | |
49365 | ||
49366 | if (dec_BER_PDU('A3800101FF0000'O) == myValue) | |
49367 | ||
49368 | ||
49369 | {setverdict(pass);} else {setverdict(fail);} | |
49370 | ||
49371 | ||
49372 | <RESULT> | |
49373 | ||
49374 | Overall verdict: pass | |
49375 | ||
49376 | <END_TC> | |
49377 | ||
49378 | :exmp. | |
49379 | ||
49380 | .*---------------------------------------------------------------------* | |
49381 | :h3. DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE | |
49382 | .*---------------------------------------------------------------------* | |
49383 | :xmp tab=0. | |
49384 | ||
49385 | <TC - DER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE> | |
49386 | ||
49387 | <STATIC:ASN> | |
49388 | ||
49389 | TempA | |
49390 | ||
49391 | DEFINITIONS | |
49392 | ||
49393 | EXPLICIT TAGS | |
49394 | ||
49395 | ||
49396 | ||
49397 | ::= | |
49398 | ||
49399 | BEGIN | |
49400 | ||
49401 | ||
49402 | BERPDU ::= CHOICE | |
49403 | { | |
49404 | b [3] EXPLICIT BOOLEAN, | |
49405 | c [6] INTEGER | |
49406 | } | |
49407 | ||
49408 | ||
49409 | ||
49410 | ||
49411 | END | |
49412 | ||
49413 | <STATIC> | |
49414 | ||
49415 | import from TempA all; | |
49416 | ||
49417 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49418 | ||
49419 | const BERPDU myValue := {b := true } | |
49420 | ||
49421 | ||
49422 | ||
49423 | <TTCN_TC:EXEC> | |
49424 | ||
49425 | if (dec_BER_PDU('A3030101FF'O) == myValue) | |
49426 | ||
49427 | ||
49428 | {setverdict(pass);} else {setverdict(fail);} | |
49429 | ||
49430 | ||
49431 | <RESULT> | |
49432 | ||
49433 | Overall verdict: pass | |
49434 | ||
49435 | <END_TC> | |
49436 | ||
49437 | :exmp. | |
49438 | ||
49439 | .*---------------------------------------------------------------------* | |
49440 | :h3. CER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE | |
49441 | .*---------------------------------------------------------------------* | |
49442 | :xmp tab=0. | |
49443 | ||
49444 | <TC - CER decoding of CHOICE - Default EXPLICIT TAGS, fully-tagged CHOICE> | |
49445 | ||
49446 | <STATIC:ASN> | |
49447 | ||
49448 | TempA | |
49449 | ||
49450 | DEFINITIONS | |
49451 | ||
49452 | EXPLICIT TAGS | |
49453 | ||
49454 | ||
49455 | ||
49456 | ::= | |
49457 | ||
49458 | BEGIN | |
49459 | ||
49460 | ||
49461 | BERPDU ::= CHOICE | |
49462 | { | |
49463 | b [3] EXPLICIT BOOLEAN, | |
49464 | c [6] INTEGER | |
49465 | } | |
49466 | ||
49467 | ||
49468 | ||
49469 | ||
49470 | END | |
49471 | ||
49472 | <STATIC> | |
49473 | ||
49474 | import from TempA all; | |
49475 | ||
49476 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49477 | ||
49478 | const BERPDU myValue := {b := true } | |
49479 | ||
49480 | ||
49481 | ||
49482 | <TTCN_TC:EXEC> | |
49483 | ||
49484 | if (dec_BER_PDU('A3800101FF0000'O) == myValue) | |
49485 | ||
49486 | ||
49487 | {setverdict(pass);} else {setverdict(fail);} | |
49488 | ||
49489 | ||
49490 | <RESULT> | |
49491 | ||
49492 | Overall verdict: pass | |
49493 | ||
49494 | <END_TC> | |
49495 | ||
49496 | :exmp. | |
49497 | ||
49498 | .*---------------------------------------------------------------------* | |
49499 | :h3. DER decoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE, | |
49500 | .*---------------------------------------------------------------------* | |
49501 | :xmp tab=0. | |
49502 | ||
49503 | <TC - DER decoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,> | |
49504 | ||
49505 | <STATIC:ASN> | |
49506 | ||
49507 | TempA | |
49508 | ||
49509 | DEFINITIONS | |
49510 | ||
49511 | IMPLICIT TAGS | |
49512 | ||
49513 | ||
49514 | ||
49515 | ::= | |
49516 | ||
49517 | BEGIN | |
49518 | ||
49519 | ||
49520 | ||
49521 | BERPDU ::= [0] CHOICE | |
49522 | { | |
49523 | b [3] BOOLEAN, | |
49524 | c [6] INTEGER | |
49525 | } | |
49526 | ||
49527 | ||
49528 | ||
49529 | ||
49530 | END | |
49531 | ||
49532 | <STATIC> | |
49533 | ||
49534 | import from TempA all; | |
49535 | ||
49536 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49537 | ||
49538 | const BERPDU myValue := {b := true } | |
49539 | ||
49540 | ||
49541 | ||
49542 | <TTCN_TC:EXEC> | |
49543 | ||
49544 | if (dec_BER_PDU('A0038301FF'O) == myValue) | |
49545 | ||
49546 | ||
49547 | {setverdict(pass);} else {setverdict(fail);} | |
49548 | ||
49549 | ||
49550 | <RESULT> | |
49551 | ||
49552 | Overall verdict: pass | |
49553 | ||
49554 | <END_TC> | |
49555 | ||
49556 | :exmp. | |
49557 | ||
49558 | .*---------------------------------------------------------------------* | |
49559 | :h3. CER decoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE, | |
49560 | .*---------------------------------------------------------------------* | |
49561 | :xmp tab=0. | |
49562 | ||
49563 | <TC - CER decoding of CHOICE - DEFAULT IMPLICIT, TAGGED CHOICE,> | |
49564 | ||
49565 | <STATIC:ASN> | |
49566 | ||
49567 | TempA | |
49568 | ||
49569 | DEFINITIONS | |
49570 | ||
49571 | IMPLICIT TAGS | |
49572 | ||
49573 | ||
49574 | ||
49575 | ::= | |
49576 | ||
49577 | BEGIN | |
49578 | ||
49579 | ||
49580 | ||
49581 | BERPDU ::= [0] CHOICE | |
49582 | { | |
49583 | b [3] BOOLEAN, | |
49584 | c [6] INTEGER | |
49585 | } | |
49586 | ||
49587 | ||
49588 | ||
49589 | ||
49590 | END | |
49591 | ||
49592 | <STATIC> | |
49593 | ||
49594 | import from TempA all; | |
49595 | ||
49596 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49597 | ||
49598 | const BERPDU myValue := {b := true } | |
49599 | ||
49600 | ||
49601 | ||
49602 | <TTCN_TC:EXEC> | |
49603 | ||
49604 | if (dec_BER_PDU('A0808301FF0000'O) == myValue) | |
49605 | ||
49606 | ||
49607 | {setverdict(pass);} else {setverdict(fail);} | |
49608 | ||
49609 | ||
49610 | <RESULT> | |
49611 | ||
49612 | Overall verdict: pass | |
49613 | ||
49614 | <END_TC> | |
49615 | ||
49616 | :exmp. | |
49617 | ||
49618 | .*---------------------------------------------------------------------* | |
49619 | :h3. DER decoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE, | |
49620 | .*---------------------------------------------------------------------* | |
49621 | :xmp tab=0. | |
49622 | ||
49623 | <TC - DER decoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,> | |
49624 | ||
49625 | <STATIC:ASN> | |
49626 | ||
49627 | TempA | |
49628 | ||
49629 | DEFINITIONS | |
49630 | ||
49631 | EXPLICIT TAGS | |
49632 | ||
49633 | ||
49634 | ||
49635 | ::= | |
49636 | ||
49637 | BEGIN | |
49638 | ||
49639 | ||
49640 | ||
49641 | BERPDU ::= [0] CHOICE | |
49642 | { | |
49643 | b [3] BOOLEAN, | |
49644 | c [6] INTEGER | |
49645 | } | |
49646 | ||
49647 | ||
49648 | ||
49649 | ||
49650 | END | |
49651 | ||
49652 | <STATIC> | |
49653 | ||
49654 | import from TempA all; | |
49655 | ||
49656 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49657 | ||
49658 | const BERPDU myValue := {b := true } | |
49659 | ||
49660 | ||
49661 | ||
49662 | <TTCN_TC:EXEC> | |
49663 | ||
49664 | if (dec_BER_PDU('A005A3030101FF'O) == myValue) | |
49665 | ||
49666 | ||
49667 | {setverdict(pass);} else {setverdict(fail);} | |
49668 | ||
49669 | ||
49670 | <RESULT> | |
49671 | ||
49672 | Overall verdict: pass | |
49673 | ||
49674 | <END_TC> | |
49675 | ||
49676 | :exmp. | |
49677 | ||
49678 | .*---------------------------------------------------------------------* | |
49679 | :h3. CER decoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE, | |
49680 | .*---------------------------------------------------------------------* | |
49681 | :xmp tab=0. | |
49682 | ||
49683 | <TC - CER decoding of CHOICE ,DEFAULT EXPLICIT, TAGGED CHOICE,> | |
49684 | ||
49685 | <STATIC:ASN> | |
49686 | ||
49687 | TempA | |
49688 | ||
49689 | DEFINITIONS | |
49690 | ||
49691 | EXPLICIT TAGS | |
49692 | ||
49693 | ||
49694 | ||
49695 | ::= | |
49696 | ||
49697 | BEGIN | |
49698 | ||
49699 | ||
49700 | ||
49701 | BERPDU ::= [0] CHOICE | |
49702 | { | |
49703 | b [3] BOOLEAN, | |
49704 | c [6] INTEGER | |
49705 | } | |
49706 | ||
49707 | ||
49708 | ||
49709 | ||
49710 | END | |
49711 | ||
49712 | <STATIC> | |
49713 | ||
49714 | import from TempA all; | |
49715 | ||
49716 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49717 | ||
49718 | const BERPDU myValue := {b := true } | |
49719 | ||
49720 | ||
49721 | ||
49722 | <TTCN_TC:EXEC> | |
49723 | ||
49724 | if (dec_BER_PDU('A080A3800101FF00000000'O) == myValue) | |
49725 | ||
49726 | ||
49727 | {setverdict(pass);} else {setverdict(fail);} | |
49728 | ||
49729 | ||
49730 | <RESULT> | |
49731 | ||
49732 | Overall verdict: pass | |
49733 | ||
49734 | <END_TC> | |
49735 | ||
49736 | :exmp. | |
49737 | ||
49738 | .*---------------------------------------------------------------------* | |
49739 | :h3. DER decoding of CHOICE, NO DEFAULT, TAGGED CHOICE, | |
49740 | .*---------------------------------------------------------------------* | |
49741 | :xmp tab=0. | |
49742 | ||
49743 | <TC - DER decoding of CHOICE, NO DEFAULT, TAGGED CHOICE,> | |
49744 | ||
49745 | <STATIC:ASN> | |
49746 | ||
49747 | TempA | |
49748 | ||
49749 | DEFINITIONS | |
49750 | ||
49751 | ||
49752 | ||
49753 | ||
49754 | ::= | |
49755 | ||
49756 | BEGIN | |
49757 | ||
49758 | ||
49759 | ||
49760 | BERPDU ::= [0] CHOICE | |
49761 | { | |
49762 | b [3] BOOLEAN, | |
49763 | c [6] INTEGER | |
49764 | } | |
49765 | ||
49766 | ||
49767 | ||
49768 | ||
49769 | END | |
49770 | ||
49771 | <STATIC> | |
49772 | ||
49773 | import from TempA all; | |
49774 | ||
49775 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49776 | ||
49777 | const BERPDU myValue := {b := true } | |
49778 | ||
49779 | ||
49780 | ||
49781 | <TTCN_TC:EXEC> | |
49782 | ||
49783 | if (dec_BER_PDU('A005A3030101FF'O) == myValue) | |
49784 | ||
49785 | ||
49786 | {setverdict(pass);} else {setverdict(fail);} | |
49787 | ||
49788 | ||
49789 | <RESULT> | |
49790 | ||
49791 | Overall verdict: pass | |
49792 | ||
49793 | <END_TC> | |
49794 | ||
49795 | :exmp. | |
49796 | ||
49797 | .*---------------------------------------------------------------------* | |
49798 | :h3. CER decoding of CHOICE, NO DEFAULT, TAGGED CHOICE, | |
49799 | .*---------------------------------------------------------------------* | |
49800 | :xmp tab=0. | |
49801 | ||
49802 | <TC - CER decoding of CHOICE, NO DEFAULT, TAGGED CHOICE,> | |
49803 | ||
49804 | <STATIC:ASN> | |
49805 | ||
49806 | TempA | |
49807 | ||
49808 | DEFINITIONS | |
49809 | ||
49810 | ||
49811 | ||
49812 | ||
49813 | ::= | |
49814 | ||
49815 | BEGIN | |
49816 | ||
49817 | ||
49818 | ||
49819 | BERPDU ::= [0] CHOICE | |
49820 | { | |
49821 | b [3] BOOLEAN, | |
49822 | c [6] INTEGER | |
49823 | } | |
49824 | ||
49825 | ||
49826 | ||
49827 | ||
49828 | END | |
49829 | ||
49830 | <STATIC> | |
49831 | ||
49832 | import from TempA all; | |
49833 | ||
49834 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49835 | ||
49836 | const BERPDU myValue := {b := true } | |
49837 | ||
49838 | ||
49839 | ||
49840 | <TTCN_TC:EXEC> | |
49841 | ||
49842 | if (dec_BER_PDU('A080A3800101FF00000000'O) == myValue) | |
49843 | ||
49844 | ||
49845 | {setverdict(pass);} else {setverdict(fail);} | |
49846 | ||
49847 | ||
49848 | <RESULT> | |
49849 | ||
49850 | Overall verdict: pass | |
49851 | ||
49852 | <END_TC> | |
49853 | ||
49854 | :exmp. | |
49855 | ||
49856 | .*---------------------------------------------------------------------* | |
49857 | :h3. DER decoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE, | |
49858 | .*---------------------------------------------------------------------* | |
49859 | :xmp tab=0. | |
49860 | ||
49861 | <TC - DER decoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,> | |
49862 | ||
49863 | <STATIC:ASN> | |
49864 | ||
49865 | TempA | |
49866 | ||
49867 | DEFINITIONS | |
49868 | ||
49869 | AUTOMATIC TAGS | |
49870 | ||
49871 | ||
49872 | ||
49873 | ::= | |
49874 | ||
49875 | BEGIN | |
49876 | ||
49877 | ||
49878 | ||
49879 | BERPDU ::= [0] CHOICE | |
49880 | { | |
49881 | b [3] BOOLEAN, | |
49882 | c [6] INTEGER | |
49883 | } | |
49884 | ||
49885 | ||
49886 | ||
49887 | ||
49888 | END | |
49889 | ||
49890 | <STATIC> | |
49891 | ||
49892 | import from TempA all; | |
49893 | ||
49894 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49895 | ||
49896 | const BERPDU myValue := {b := true } | |
49897 | ||
49898 | ||
49899 | ||
49900 | <TTCN_TC:EXEC> | |
49901 | ||
49902 | if (dec_BER_PDU('A0038301FF'O) == myValue) | |
49903 | ||
49904 | ||
49905 | {setverdict(pass);} else {setverdict(fail);} | |
49906 | ||
49907 | ||
49908 | <RESULT> | |
49909 | ||
49910 | Overall verdict: pass | |
49911 | ||
49912 | <END_TC> | |
49913 | ||
49914 | :exmp. | |
49915 | ||
49916 | .*---------------------------------------------------------------------* | |
49917 | :h3. CER decoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE, | |
49918 | .*---------------------------------------------------------------------* | |
49919 | :xmp tab=0. | |
49920 | ||
49921 | <TC - CER decoding of CHOICE ,DEFAULT AUTOMATIC, TAGGED CHOICE,> | |
49922 | ||
49923 | <STATIC:ASN> | |
49924 | ||
49925 | TempA | |
49926 | ||
49927 | DEFINITIONS | |
49928 | ||
49929 | AUTOMATIC TAGS | |
49930 | ||
49931 | ||
49932 | ||
49933 | ::= | |
49934 | ||
49935 | BEGIN | |
49936 | ||
49937 | ||
49938 | ||
49939 | BERPDU ::= [0] CHOICE | |
49940 | { | |
49941 | b [3] BOOLEAN, | |
49942 | c [6] INTEGER | |
49943 | } | |
49944 | ||
49945 | ||
49946 | ||
49947 | ||
49948 | END | |
49949 | ||
49950 | <STATIC> | |
49951 | ||
49952 | import from TempA all; | |
49953 | ||
49954 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
49955 | ||
49956 | const BERPDU myValue := {b := true } | |
49957 | ||
49958 | ||
49959 | ||
49960 | <TTCN_TC:EXEC> | |
49961 | ||
49962 | if (dec_BER_PDU('A0808301FF0000'O) == myValue) | |
49963 | ||
49964 | ||
49965 | {setverdict(pass);} else {setverdict(fail);} | |
49966 | ||
49967 | ||
49968 | <RESULT> | |
49969 | ||
49970 | Overall verdict: pass | |
49971 | ||
49972 | <END_TC> | |
49973 | ||
49974 | :exmp. | |
49975 | ||
49976 | .*---------------------------------------------------------------------* | |
49977 | :h3.CER + DER encoding of OBJECT IDENTIFIER , itu-t(0) recommendation(0) (primitive) | |
49978 | .*---------------------------------------------------------------------* | |
49979 | :xmp tab=0. | |
49980 | ||
49981 | <TC - CER + DER encoding of OBJECT IDENTIFIER , itu-t(0) recommendation(0) (primitive)> | |
49982 | ||
49983 | <STATIC:ASN> | |
49984 | ||
49985 | TempA | |
49986 | ||
49987 | DEFINITIONS ::= | |
49988 | BEGIN | |
49989 | BERPDU ::= OBJECT IDENTIFIER | |
49990 | b BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
49991 | ||
49992 | END | |
49993 | ||
49994 | <STATIC> | |
49995 | ||
49996 | import from TempA all; | |
49997 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
49998 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
49999 | ||
50000 | ||
50001 | ||
50002 | <TTCN_TC:EXEC> | |
50003 | ||
50004 | if ((enc_DER_PDU(b) == '0603000203'O)and(enc_CER_PDU(b) == '0603000203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50005 | ||
50006 | <RESULT> | |
50007 | ||
50008 | Overall verdict: pass | |
50009 | ||
50010 | <END_TC> | |
50011 | ||
50012 | :exmp. | |
50013 | ||
50014 | .*---------------------------------------------------------------------* | |
50015 | :h3.CER + DER encoding of OBJECT IDENTIFIER , itu-t recommendation (primitive) | |
50016 | .*---------------------------------------------------------------------* | |
50017 | :xmp tab=0. | |
50018 | ||
50019 | <TC - CER + DER encoding of OBJECT IDENTIFIER , itu-t recommendation (primitive)> | |
50020 | ||
50021 | <STATIC:ASN> | |
50022 | ||
50023 | TempA | |
50024 | ||
50025 | DEFINITIONS ::= | |
50026 | BEGIN | |
50027 | BERPDU ::= OBJECT IDENTIFIER | |
50028 | b BERPDU ::= {itu-t recommendation a(2) b(3)} | |
50029 | ||
50030 | END | |
50031 | ||
50032 | <STATIC> | |
50033 | ||
50034 | import from TempA all; | |
50035 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50036 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50037 | ||
50038 | ||
50039 | ||
50040 | <TTCN_TC:EXEC> | |
50041 | ||
50042 | if ((enc_DER_PDU(b) == '0603000203'O)and(enc_CER_PDU(b) == '0603000203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50043 | ||
50044 | <RESULT> | |
50045 | ||
50046 | Overall verdict: pass | |
50047 | ||
50048 | <END_TC> | |
50049 | ||
50050 | :exmp. | |
50051 | ||
50052 | .*---------------------------------------------------------------------* | |
50053 | :h3.CER + DER encoding of OBJECT IDENTIFIER , 0 0 (primitive) | |
50054 | .*---------------------------------------------------------------------* | |
50055 | :xmp tab=0. | |
50056 | ||
50057 | <TC - CER + DER encoding of OBJECT IDENTIFIER , 0 0 (primitive)> | |
50058 | ||
50059 | <STATIC:ASN> | |
50060 | ||
50061 | TempA | |
50062 | ||
50063 | DEFINITIONS ::= | |
50064 | BEGIN | |
50065 | BERPDU ::= OBJECT IDENTIFIER | |
50066 | b BERPDU ::= {0 0 a(2) b(3)} | |
50067 | ||
50068 | END | |
50069 | ||
50070 | <STATIC> | |
50071 | ||
50072 | import from TempA all; | |
50073 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50074 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50075 | ||
50076 | ||
50077 | ||
50078 | <TTCN_TC:EXEC> | |
50079 | ||
50080 | if ((enc_DER_PDU(b) == '0603000203'O)and(enc_CER_PDU(b) == '0603000203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50081 | ||
50082 | <RESULT> | |
50083 | ||
50084 | Overall verdict: pass | |
50085 | ||
50086 | <END_TC> | |
50087 | ||
50088 | :exmp. | |
50089 | ||
50090 | .*---------------------------------------------------------------------* | |
50091 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) question(1),(primitive) | |
50092 | .*---------------------------------------------------------------------* | |
50093 | :xmp tab=0. | |
50094 | ||
50095 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) question(1),(primitive)> | |
50096 | ||
50097 | <STATIC:ASN> | |
50098 | ||
50099 | TempA | |
50100 | ||
50101 | DEFINITIONS ::= | |
50102 | BEGIN | |
50103 | BERPDU ::= OBJECT IDENTIFIER | |
50104 | b BERPDU ::= {itu-t(0) question(1) a(2) b(3)} | |
50105 | ||
50106 | END | |
50107 | ||
50108 | <STATIC> | |
50109 | ||
50110 | import from TempA all; | |
50111 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50112 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50113 | ||
50114 | ||
50115 | ||
50116 | <TTCN_TC:EXEC> | |
50117 | ||
50118 | if ((enc_DER_PDU(b) == '0603010203'O)and(enc_CER_PDU(b) == '0603010203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50119 | ||
50120 | <RESULT> | |
50121 | ||
50122 | Overall verdict: pass | |
50123 | ||
50124 | <END_TC> | |
50125 | ||
50126 | :exmp. | |
50127 | ||
50128 | .*---------------------------------------------------------------------* | |
50129 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t question,(primitive) | |
50130 | .*---------------------------------------------------------------------* | |
50131 | :xmp tab=0. | |
50132 | ||
50133 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t question,(primitive)> | |
50134 | ||
50135 | <STATIC:ASN> | |
50136 | ||
50137 | TempA | |
50138 | ||
50139 | DEFINITIONS ::= | |
50140 | BEGIN | |
50141 | BERPDU ::= OBJECT IDENTIFIER | |
50142 | b BERPDU ::= {itu-t question a(2) b(3)} | |
50143 | ||
50144 | END | |
50145 | ||
50146 | <STATIC> | |
50147 | ||
50148 | import from TempA all; | |
50149 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50150 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50151 | ||
50152 | ||
50153 | ||
50154 | <TTCN_TC:EXEC> | |
50155 | ||
50156 | if ((enc_DER_PDU(b) == '0603010203'O)and(enc_CER_PDU(b) == '0603010203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50157 | ||
50158 | <RESULT> | |
50159 | ||
50160 | Overall verdict: pass | |
50161 | ||
50162 | <END_TC> | |
50163 | ||
50164 | :exmp. | |
50165 | ||
50166 | .*---------------------------------------------------------------------* | |
50167 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,0 1,(primitive) | |
50168 | .*---------------------------------------------------------------------* | |
50169 | :xmp tab=0. | |
50170 | ||
50171 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,0 1,(primitive)> | |
50172 | ||
50173 | <STATIC:ASN> | |
50174 | ||
50175 | TempA | |
50176 | ||
50177 | DEFINITIONS ::= | |
50178 | BEGIN | |
50179 | BERPDU ::= OBJECT IDENTIFIER | |
50180 | b BERPDU ::= {0 1 a(2) b(3)} | |
50181 | ||
50182 | END | |
50183 | ||
50184 | <STATIC> | |
50185 | ||
50186 | import from TempA all; | |
50187 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50188 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50189 | ||
50190 | ||
50191 | ||
50192 | <TTCN_TC:EXEC> | |
50193 | ||
50194 | if ((enc_DER_PDU(b) == '0603010203'O)and(enc_CER_PDU(b) == '0603010203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50195 | ||
50196 | <RESULT> | |
50197 | ||
50198 | Overall verdict: pass | |
50199 | ||
50200 | <END_TC> | |
50201 | ||
50202 | :exmp. | |
50203 | ||
50204 | .*---------------------------------------------------------------------* | |
50205 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) administration(2),(primitive) | |
50206 | .*---------------------------------------------------------------------* | |
50207 | :xmp tab=0. | |
50208 | ||
50209 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) administration(2),(primitive)> | |
50210 | ||
50211 | <STATIC:ASN> | |
50212 | ||
50213 | TempA | |
50214 | ||
50215 | DEFINITIONS ::= | |
50216 | BEGIN | |
50217 | BERPDU ::= OBJECT IDENTIFIER | |
50218 | b BERPDU ::= {itu-t(0) administration(2) a(2) b(3)} | |
50219 | ||
50220 | END | |
50221 | ||
50222 | <STATIC> | |
50223 | ||
50224 | import from TempA all; | |
50225 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50226 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50227 | ||
50228 | ||
50229 | ||
50230 | <TTCN_TC:EXEC> | |
50231 | ||
50232 | if ((enc_DER_PDU(b) == '0603020203'O)and(enc_CER_PDU(b) == '0603020203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50233 | ||
50234 | <RESULT> | |
50235 | ||
50236 | Overall verdict: pass | |
50237 | ||
50238 | <END_TC> | |
50239 | ||
50240 | :exmp. | |
50241 | ||
50242 | .*---------------------------------------------------------------------* | |
50243 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t administration,(primitive) | |
50244 | .*---------------------------------------------------------------------* | |
50245 | :xmp tab=0. | |
50246 | ||
50247 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t administration,(primitive)> | |
50248 | ||
50249 | <STATIC:ASN> | |
50250 | ||
50251 | TempA | |
50252 | ||
50253 | DEFINITIONS ::= | |
50254 | BEGIN | |
50255 | BERPDU ::= OBJECT IDENTIFIER | |
50256 | b BERPDU ::= {itu-t administration a(2) b(3)} | |
50257 | ||
50258 | END | |
50259 | ||
50260 | <STATIC> | |
50261 | ||
50262 | import from TempA all; | |
50263 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50264 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50265 | ||
50266 | ||
50267 | ||
50268 | <TTCN_TC:EXEC> | |
50269 | ||
50270 | if ((enc_DER_PDU(b) == '0603020203'O)and(enc_CER_PDU(b) == '0603020203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50271 | ||
50272 | <RESULT> | |
50273 | ||
50274 | Overall verdict: pass | |
50275 | ||
50276 | <END_TC> | |
50277 | ||
50278 | :exmp. | |
50279 | ||
50280 | .*---------------------------------------------------------------------* | |
50281 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,0 2,(primitive) | |
50282 | .*---------------------------------------------------------------------* | |
50283 | :xmp tab=0. | |
50284 | ||
50285 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,0 2,(primitive)> | |
50286 | ||
50287 | <STATIC:ASN> | |
50288 | ||
50289 | TempA | |
50290 | ||
50291 | DEFINITIONS ::= | |
50292 | BEGIN | |
50293 | BERPDU ::= OBJECT IDENTIFIER | |
50294 | b BERPDU ::= {0 2 a(2) b(3)} | |
50295 | ||
50296 | END | |
50297 | ||
50298 | <STATIC> | |
50299 | ||
50300 | import from TempA all; | |
50301 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50302 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50303 | ||
50304 | ||
50305 | ||
50306 | <TTCN_TC:EXEC> | |
50307 | ||
50308 | if ((enc_DER_PDU(b) == '0603020203'O)and(enc_CER_PDU(b) == '0603020203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50309 | ||
50310 | <RESULT> | |
50311 | ||
50312 | Overall verdict: pass | |
50313 | ||
50314 | <END_TC> | |
50315 | ||
50316 | :exmp. | |
50317 | ||
50318 | .*---------------------------------------------------------------------* | |
50319 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) network-operator(3),(primitive) | |
50320 | .*---------------------------------------------------------------------* | |
50321 | :xmp tab=0. | |
50322 | ||
50323 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) network-operator(3),(primitive)> | |
50324 | ||
50325 | <STATIC:ASN> | |
50326 | ||
50327 | TempA | |
50328 | ||
50329 | DEFINITIONS ::= | |
50330 | BEGIN | |
50331 | BERPDU ::= OBJECT IDENTIFIER | |
50332 | b BERPDU ::= {itu-t(0) network-operator(3) a(2) b(3)} | |
50333 | ||
50334 | END | |
50335 | ||
50336 | <STATIC> | |
50337 | ||
50338 | import from TempA all; | |
50339 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50340 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50341 | ||
50342 | ||
50343 | ||
50344 | <TTCN_TC:EXEC> | |
50345 | ||
50346 | if ((enc_DER_PDU(b) == '0603030203'O)and(enc_CER_PDU(b) == '0603030203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50347 | ||
50348 | <RESULT> | |
50349 | ||
50350 | Overall verdict: pass | |
50351 | ||
50352 | <END_TC> | |
50353 | ||
50354 | :exmp. | |
50355 | ||
50356 | .*---------------------------------------------------------------------* | |
50357 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t network-operator,(primitive) | |
50358 | .*---------------------------------------------------------------------* | |
50359 | :xmp tab=0. | |
50360 | ||
50361 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t network-operator,(primitive)> | |
50362 | ||
50363 | <STATIC:ASN> | |
50364 | ||
50365 | TempA | |
50366 | ||
50367 | DEFINITIONS ::= | |
50368 | BEGIN | |
50369 | BERPDU ::= OBJECT IDENTIFIER | |
50370 | b BERPDU ::= {itu-t network-operator a(2) b(3)} | |
50371 | ||
50372 | END | |
50373 | ||
50374 | <STATIC> | |
50375 | ||
50376 | import from TempA all; | |
50377 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50378 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50379 | ||
50380 | ||
50381 | ||
50382 | <TTCN_TC:EXEC> | |
50383 | ||
50384 | if ((enc_DER_PDU(b) == '0603030203'O)and(enc_CER_PDU(b) == '0603030203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50385 | ||
50386 | <RESULT> | |
50387 | ||
50388 | Overall verdict: pass | |
50389 | ||
50390 | <END_TC> | |
50391 | ||
50392 | :exmp. | |
50393 | ||
50394 | .*---------------------------------------------------------------------* | |
50395 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,0 3,(primitive) | |
50396 | .*---------------------------------------------------------------------* | |
50397 | :xmp tab=0. | |
50398 | ||
50399 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,0 3,(primitive)> | |
50400 | ||
50401 | <STATIC:ASN> | |
50402 | ||
50403 | TempA | |
50404 | ||
50405 | DEFINITIONS ::= | |
50406 | BEGIN | |
50407 | BERPDU ::= OBJECT IDENTIFIER | |
50408 | b BERPDU ::= {0 3 a(2) b(3)} | |
50409 | ||
50410 | END | |
50411 | ||
50412 | <STATIC> | |
50413 | ||
50414 | import from TempA all; | |
50415 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50416 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50417 | ||
50418 | ||
50419 | ||
50420 | <TTCN_TC:EXEC> | |
50421 | ||
50422 | if ((enc_DER_PDU(b) == '0603030203'O)and(enc_CER_PDU(b) == '0603030203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50423 | ||
50424 | <RESULT> | |
50425 | ||
50426 | Overall verdict: pass | |
50427 | ||
50428 | <END_TC> | |
50429 | ||
50430 | :exmp. | |
50431 | ||
50432 | .*---------------------------------------------------------------------* | |
50433 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) identified-organization(4),(primitive) | |
50434 | .*---------------------------------------------------------------------* | |
50435 | :xmp tab=0. | |
50436 | ||
50437 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t(0) identified-organization(4),(primitive)> | |
50438 | ||
50439 | <STATIC:ASN> | |
50440 | ||
50441 | TempA | |
50442 | ||
50443 | DEFINITIONS ::= | |
50444 | BEGIN | |
50445 | BERPDU ::= OBJECT IDENTIFIER | |
50446 | b BERPDU ::= {itu-t(0) identified-organization(4) a(2) b(3)} | |
50447 | ||
50448 | END | |
50449 | ||
50450 | <STATIC> | |
50451 | ||
50452 | import from TempA all; | |
50453 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50454 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50455 | ||
50456 | ||
50457 | ||
50458 | <TTCN_TC:EXEC> | |
50459 | ||
50460 | if ((enc_DER_PDU(b) == '0603040203'O)and(enc_CER_PDU(b) == '0603040203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50461 | ||
50462 | <RESULT> | |
50463 | ||
50464 | Overall verdict: pass | |
50465 | ||
50466 | <END_TC> | |
50467 | ||
50468 | :exmp. | |
50469 | ||
50470 | .*---------------------------------------------------------------------* | |
50471 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,itu-t identified-organization,(primitive) | |
50472 | .*---------------------------------------------------------------------* | |
50473 | :xmp tab=0. | |
50474 | ||
50475 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,itu-t identified-organization,(primitive)> | |
50476 | ||
50477 | <STATIC:ASN> | |
50478 | ||
50479 | TempA | |
50480 | ||
50481 | DEFINITIONS ::= | |
50482 | BEGIN | |
50483 | BERPDU ::= OBJECT IDENTIFIER | |
50484 | b BERPDU ::= {itu-t identified-organization a(2) b(3)} | |
50485 | ||
50486 | END | |
50487 | ||
50488 | <STATIC> | |
50489 | ||
50490 | import from TempA all; | |
50491 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50492 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50493 | ||
50494 | ||
50495 | ||
50496 | <TTCN_TC:EXEC> | |
50497 | ||
50498 | if ((enc_DER_PDU(b) == '0603040203'O)and(enc_CER_PDU(b) == '0603040203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50499 | ||
50500 | <RESULT> | |
50501 | ||
50502 | Overall verdict: pass | |
50503 | ||
50504 | <END_TC> | |
50505 | ||
50506 | :exmp. | |
50507 | ||
50508 | .*---------------------------------------------------------------------* | |
50509 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,0 4,(primitive) | |
50510 | .*---------------------------------------------------------------------* | |
50511 | :xmp tab=0. | |
50512 | ||
50513 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,0 4,(primitive)> | |
50514 | ||
50515 | <STATIC:ASN> | |
50516 | ||
50517 | TempA | |
50518 | ||
50519 | DEFINITIONS ::= | |
50520 | BEGIN | |
50521 | BERPDU ::= OBJECT IDENTIFIER | |
50522 | b BERPDU ::= {0 4 a(2) b(3)} | |
50523 | ||
50524 | END | |
50525 | ||
50526 | <STATIC> | |
50527 | ||
50528 | import from TempA all; | |
50529 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50530 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50531 | ||
50532 | ||
50533 | ||
50534 | <TTCN_TC:EXEC> | |
50535 | ||
50536 | if ((enc_DER_PDU(b) == '0603040203'O)and(enc_CER_PDU(b) == '0603040203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50537 | ||
50538 | <RESULT> | |
50539 | ||
50540 | Overall verdict: pass | |
50541 | ||
50542 | <END_TC> | |
50543 | ||
50544 | :exmp. | |
50545 | ||
50546 | .*---------------------------------------------------------------------* | |
50547 | :h3.CER + DER encoding of OBJECT IDENTIFIER , iso(1) standard(0) (primitive) | |
50548 | .*---------------------------------------------------------------------* | |
50549 | :xmp tab=0. | |
50550 | ||
50551 | <TC - CER + DER encoding of OBJECT IDENTIFIER , iso(1) standard(0) (primitive)> | |
50552 | ||
50553 | <STATIC:ASN> | |
50554 | ||
50555 | TempA | |
50556 | ||
50557 | DEFINITIONS ::= | |
50558 | BEGIN | |
50559 | BERPDU ::= OBJECT IDENTIFIER | |
50560 | b BERPDU ::= {iso(1) standard(0) a(2) b(3)} | |
50561 | ||
50562 | END | |
50563 | ||
50564 | <STATIC> | |
50565 | ||
50566 | import from TempA all; | |
50567 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50568 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50569 | ||
50570 | ||
50571 | ||
50572 | <TTCN_TC:EXEC> | |
50573 | ||
50574 | if ((enc_DER_PDU(b) == '0603280203'O)and(enc_CER_PDU(b) == '0603280203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50575 | ||
50576 | <RESULT> | |
50577 | ||
50578 | Overall verdict: pass | |
50579 | ||
50580 | <END_TC> | |
50581 | ||
50582 | :exmp. | |
50583 | ||
50584 | .*---------------------------------------------------------------------* | |
50585 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso standard (primitive) | |
50586 | .*---------------------------------------------------------------------* | |
50587 | :xmp tab=0. | |
50588 | ||
50589 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso standard (primitive)> | |
50590 | ||
50591 | <STATIC:ASN> | |
50592 | ||
50593 | TempA | |
50594 | ||
50595 | DEFINITIONS ::= | |
50596 | BEGIN | |
50597 | BERPDU ::= OBJECT IDENTIFIER | |
50598 | b BERPDU ::= {iso standard a(2) b(3)} | |
50599 | ||
50600 | END | |
50601 | ||
50602 | <STATIC> | |
50603 | ||
50604 | import from TempA all; | |
50605 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50606 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50607 | ||
50608 | ||
50609 | ||
50610 | <TTCN_TC:EXEC> | |
50611 | ||
50612 | if ((enc_DER_PDU(b) == '0603280203'O)and(enc_CER_PDU(b) == '0603280203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50613 | ||
50614 | <RESULT> | |
50615 | ||
50616 | Overall verdict: pass | |
50617 | ||
50618 | <END_TC> | |
50619 | ||
50620 | :exmp. | |
50621 | ||
50622 | .*---------------------------------------------------------------------* | |
50623 | :h3.CER + DER encoding of OBJECT IDENTIFIER , 1 0 (primitive) | |
50624 | .*---------------------------------------------------------------------* | |
50625 | :xmp tab=0. | |
50626 | ||
50627 | <TC - CER + DER encoding of OBJECT IDENTIFIER , 1 0 (primitive)> | |
50628 | ||
50629 | <STATIC:ASN> | |
50630 | ||
50631 | TempA | |
50632 | ||
50633 | DEFINITIONS ::= | |
50634 | BEGIN | |
50635 | BERPDU ::= OBJECT IDENTIFIER | |
50636 | b BERPDU ::= {1 0 a(2) b(3)} | |
50637 | ||
50638 | END | |
50639 | ||
50640 | <STATIC> | |
50641 | ||
50642 | import from TempA all; | |
50643 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50644 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50645 | ||
50646 | ||
50647 | ||
50648 | <TTCN_TC:EXEC> | |
50649 | ||
50650 | if ((enc_DER_PDU(b) == '0603280203'O)and(enc_CER_PDU(b) == '0603280203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50651 | ||
50652 | <RESULT> | |
50653 | ||
50654 | Overall verdict: pass | |
50655 | ||
50656 | <END_TC> | |
50657 | ||
50658 | :exmp. | |
50659 | ||
50660 | .*---------------------------------------------------------------------* | |
50661 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso(1) member-body(2)(primitive) | |
50662 | .*---------------------------------------------------------------------* | |
50663 | :xmp tab=0. | |
50664 | ||
50665 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso(1) member-body(2)(primitive)> | |
50666 | ||
50667 | <STATIC:ASN> | |
50668 | ||
50669 | TempA | |
50670 | ||
50671 | DEFINITIONS ::= | |
50672 | BEGIN | |
50673 | BERPDU ::= OBJECT IDENTIFIER | |
50674 | b BERPDU ::= {iso(1) member-body(2) a(2) b(3)} | |
50675 | ||
50676 | END | |
50677 | ||
50678 | <STATIC> | |
50679 | ||
50680 | import from TempA all; | |
50681 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50682 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50683 | ||
50684 | ||
50685 | ||
50686 | <TTCN_TC:EXEC> | |
50687 | ||
50688 | if ((enc_DER_PDU(b) == '06032A0203'O)and(enc_CER_PDU(b) == '06032A0203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50689 | ||
50690 | <RESULT> | |
50691 | ||
50692 | Overall verdict: pass | |
50693 | ||
50694 | <END_TC> | |
50695 | ||
50696 | :exmp. | |
50697 | ||
50698 | .*---------------------------------------------------------------------* | |
50699 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso member-body(primitive) | |
50700 | .*---------------------------------------------------------------------* | |
50701 | :xmp tab=0. | |
50702 | ||
50703 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso member-body(primitive)> | |
50704 | ||
50705 | <STATIC:ASN> | |
50706 | ||
50707 | TempA | |
50708 | ||
50709 | DEFINITIONS ::= | |
50710 | BEGIN | |
50711 | BERPDU ::= OBJECT IDENTIFIER | |
50712 | b BERPDU ::= {iso member-body a(2) b(3)} | |
50713 | ||
50714 | END | |
50715 | ||
50716 | <STATIC> | |
50717 | ||
50718 | import from TempA all; | |
50719 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50720 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50721 | ||
50722 | ||
50723 | ||
50724 | <TTCN_TC:EXEC> | |
50725 | ||
50726 | if ((enc_DER_PDU(b) == '06032A0203'O)and(enc_CER_PDU(b) == '06032A0203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50727 | ||
50728 | <RESULT> | |
50729 | ||
50730 | Overall verdict: pass | |
50731 | ||
50732 | <END_TC> | |
50733 | ||
50734 | :exmp. | |
50735 | ||
50736 | .*---------------------------------------------------------------------* | |
50737 | :h3.CER + DER encoding of OBJECT IDENTIFIER , 1 2 (primitive) | |
50738 | .*---------------------------------------------------------------------* | |
50739 | :xmp tab=0. | |
50740 | ||
50741 | <TC - CER + DER encoding of OBJECT IDENTIFIER , 1 2 (primitive)> | |
50742 | ||
50743 | <STATIC:ASN> | |
50744 | ||
50745 | TempA | |
50746 | ||
50747 | DEFINITIONS ::= | |
50748 | BEGIN | |
50749 | BERPDU ::= OBJECT IDENTIFIER | |
50750 | b BERPDU ::= {1 2 a(2) b(3)} | |
50751 | ||
50752 | END | |
50753 | ||
50754 | <STATIC> | |
50755 | ||
50756 | import from TempA all; | |
50757 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50758 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50759 | ||
50760 | ||
50761 | ||
50762 | <TTCN_TC:EXEC> | |
50763 | ||
50764 | if ((enc_DER_PDU(b) == '06032A0203'O)and(enc_CER_PDU(b) == '06032A0203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50765 | ||
50766 | <RESULT> | |
50767 | ||
50768 | Overall verdict: pass | |
50769 | ||
50770 | <END_TC> | |
50771 | ||
50772 | :exmp. | |
50773 | ||
50774 | .*---------------------------------------------------------------------* | |
50775 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso(1) identified-organization(3) (primitive) | |
50776 | .*---------------------------------------------------------------------* | |
50777 | :xmp tab=0. | |
50778 | ||
50779 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso(1) identified-organization(3) (primitive)> | |
50780 | ||
50781 | <STATIC:ASN> | |
50782 | ||
50783 | TempA | |
50784 | ||
50785 | DEFINITIONS ::= | |
50786 | BEGIN | |
50787 | BERPDU ::= OBJECT IDENTIFIER | |
50788 | b BERPDU ::= {iso(1) identified-organization(3) a(2) b(3)} | |
50789 | ||
50790 | END | |
50791 | ||
50792 | <STATIC> | |
50793 | ||
50794 | import from TempA all; | |
50795 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50796 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50797 | ||
50798 | ||
50799 | ||
50800 | <TTCN_TC:EXEC> | |
50801 | ||
50802 | if ((enc_DER_PDU(b) == '06032B0203'O)and(enc_CER_PDU(b) == '06032B0203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50803 | ||
50804 | <RESULT> | |
50805 | ||
50806 | Overall verdict: pass | |
50807 | ||
50808 | <END_TC> | |
50809 | ||
50810 | :exmp. | |
50811 | ||
50812 | .*---------------------------------------------------------------------* | |
50813 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,iso identified-organization(primitive) | |
50814 | .*---------------------------------------------------------------------* | |
50815 | :xmp tab=0. | |
50816 | ||
50817 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,iso identified-organization(primitive)> | |
50818 | ||
50819 | <STATIC:ASN> | |
50820 | ||
50821 | TempA | |
50822 | ||
50823 | DEFINITIONS ::= | |
50824 | BEGIN | |
50825 | BERPDU ::= OBJECT IDENTIFIER | |
50826 | b BERPDU ::= {iso identified-organization a(2) b(3)} | |
50827 | ||
50828 | END | |
50829 | ||
50830 | <STATIC> | |
50831 | ||
50832 | import from TempA all; | |
50833 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50834 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50835 | ||
50836 | ||
50837 | ||
50838 | <TTCN_TC:EXEC> | |
50839 | ||
50840 | if ((enc_DER_PDU(b) == '06032B0203'O)and(enc_CER_PDU(b) == '06032B0203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50841 | ||
50842 | <RESULT> | |
50843 | ||
50844 | Overall verdict: pass | |
50845 | ||
50846 | <END_TC> | |
50847 | ||
50848 | :exmp. | |
50849 | ||
50850 | .*---------------------------------------------------------------------* | |
50851 | :h3.CER + DER encoding of OBJECT IDENTIFIER , 1 3 (primitive) | |
50852 | .*---------------------------------------------------------------------* | |
50853 | :xmp tab=0. | |
50854 | ||
50855 | <TC - CER + DER encoding of OBJECT IDENTIFIER , 1 3 (primitive)> | |
50856 | ||
50857 | <STATIC:ASN> | |
50858 | ||
50859 | TempA | |
50860 | ||
50861 | DEFINITIONS ::= | |
50862 | BEGIN | |
50863 | BERPDU ::= OBJECT IDENTIFIER | |
50864 | b BERPDU ::= {1 3 a(2) b(3)} | |
50865 | ||
50866 | END | |
50867 | ||
50868 | <STATIC> | |
50869 | ||
50870 | import from TempA all; | |
50871 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50872 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50873 | ||
50874 | ||
50875 | ||
50876 | <TTCN_TC:EXEC> | |
50877 | ||
50878 | if ((enc_DER_PDU(b) == '06032B0203'O)and(enc_CER_PDU(b) == '06032B0203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50879 | ||
50880 | <RESULT> | |
50881 | ||
50882 | Overall verdict: pass | |
50883 | ||
50884 | <END_TC> | |
50885 | ||
50886 | :exmp. | |
50887 | ||
50888 | .*---------------------------------------------------------------------* | |
50889 | :h3.CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t(2) something(0)(primitive) | |
50890 | .*---------------------------------------------------------------------* | |
50891 | :xmp tab=0. | |
50892 | ||
50893 | <TC - CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t(2) something(0)(primitive)> | |
50894 | ||
50895 | <STATIC:ASN> | |
50896 | ||
50897 | TempA | |
50898 | ||
50899 | DEFINITIONS ::= | |
50900 | BEGIN | |
50901 | BERPDU ::= OBJECT IDENTIFIER | |
50902 | b BERPDU ::= {joint-iso-itu-t(2) something(0) a(2) b(3)} | |
50903 | ||
50904 | END | |
50905 | ||
50906 | <STATIC> | |
50907 | ||
50908 | import from TempA all; | |
50909 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50910 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50911 | ||
50912 | ||
50913 | ||
50914 | <TTCN_TC:EXEC> | |
50915 | ||
50916 | if ((enc_DER_PDU(b) == '0603500203'O)and(enc_CER_PDU(b) == '0603500203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50917 | ||
50918 | <RESULT> | |
50919 | ||
50920 | Overall verdict: pass | |
50921 | ||
50922 | <END_TC> | |
50923 | ||
50924 | :exmp. | |
50925 | ||
50926 | .*---------------------------------------------------------------------* | |
50927 | :h3.CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t something(0) (primitive) | |
50928 | .*---------------------------------------------------------------------* | |
50929 | :xmp tab=0. | |
50930 | ||
50931 | <TC - CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t something(0) (primitive)> | |
50932 | ||
50933 | <STATIC:ASN> | |
50934 | ||
50935 | TempA | |
50936 | ||
50937 | DEFINITIONS ::= | |
50938 | BEGIN | |
50939 | BERPDU ::= OBJECT IDENTIFIER | |
50940 | b BERPDU ::= {joint-iso-itu-t something(0) a(2) b(3)} | |
50941 | ||
50942 | END | |
50943 | ||
50944 | <STATIC> | |
50945 | ||
50946 | import from TempA all; | |
50947 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50948 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50949 | ||
50950 | ||
50951 | ||
50952 | <TTCN_TC:EXEC> | |
50953 | ||
50954 | if ((enc_DER_PDU(b) == '0603500203'O)and(enc_CER_PDU(b) == '0603500203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50955 | ||
50956 | <RESULT> | |
50957 | ||
50958 | Overall verdict: pass | |
50959 | ||
50960 | <END_TC> | |
50961 | ||
50962 | :exmp. | |
50963 | ||
50964 | .*---------------------------------------------------------------------* | |
50965 | :h3.CER + DER encoding of OBJECT IDENTIFIER , 2 0 (primitive) | |
50966 | .*---------------------------------------------------------------------* | |
50967 | :xmp tab=0. | |
50968 | ||
50969 | <TC - CER + DER encoding of OBJECT IDENTIFIER , 2 0 (primitive)> | |
50970 | ||
50971 | <STATIC:ASN> | |
50972 | ||
50973 | TempA | |
50974 | ||
50975 | DEFINITIONS ::= | |
50976 | BEGIN | |
50977 | BERPDU ::= OBJECT IDENTIFIER | |
50978 | b BERPDU ::= {2 0 a(2) b(3)} | |
50979 | ||
50980 | END | |
50981 | ||
50982 | <STATIC> | |
50983 | ||
50984 | import from TempA all; | |
50985 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
50986 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
50987 | ||
50988 | ||
50989 | ||
50990 | <TTCN_TC:EXEC> | |
50991 | ||
50992 | if ((enc_DER_PDU(b) == '0603500203'O)and(enc_CER_PDU(b) == '0603500203'O)) {setverdict(pass);} else {setverdict(fail);} | |
50993 | ||
50994 | <RESULT> | |
50995 | ||
50996 | Overall verdict: pass | |
50997 | ||
50998 | <END_TC> | |
50999 | ||
51000 | :exmp. | |
51001 | ||
51002 | .*---------------------------------------------------------------------* | |
51003 | :h3.CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t(2) something(100) (primitive) | |
51004 | .*---------------------------------------------------------------------* | |
51005 | :xmp tab=0. | |
51006 | ||
51007 | <TC - CER + DER encoding of OBJECT IDENTIFIER , joint-iso-itu-t(2) something(100) (primitive)> | |
51008 | ||
51009 | <STATIC:ASN> | |
51010 | ||
51011 | TempA | |
51012 | ||
51013 | DEFINITIONS ::= | |
51014 | BEGIN | |
51015 | BERPDU ::= OBJECT IDENTIFIER | |
51016 | b BERPDU ::= {joint-iso-itu-t(2) something(100) a(2) b(3)} | |
51017 | ||
51018 | END | |
51019 | ||
51020 | <STATIC> | |
51021 | ||
51022 | import from TempA all; | |
51023 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
51024 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
51025 | ||
51026 | ||
51027 | ||
51028 | <TTCN_TC:EXEC> | |
51029 | ||
51030 | if ((enc_DER_PDU(b) == '060481340203'O)and(enc_CER_PDU(b) == '060481340203'O)) {setverdict(pass);} else {setverdict(fail);} | |
51031 | ||
51032 | <RESULT> | |
51033 | ||
51034 | Overall verdict: pass | |
51035 | ||
51036 | <END_TC> | |
51037 | ||
51038 | :exmp. | |
51039 | ||
51040 | .*---------------------------------------------------------------------* | |
51041 | :h3.CER + DER encoding of OBJECT IDENTIFIER ,joint-iso-itu-t 100 (primitive) | |
51042 | .*---------------------------------------------------------------------* | |
51043 | :xmp tab=0. | |
51044 | ||
51045 | <TC - CER + DER encoding of OBJECT IDENTIFIER ,joint-iso-itu-t 100 (primitive)> | |
51046 | ||
51047 | <STATIC:ASN> | |
51048 | ||
51049 | TempA | |
51050 | ||
51051 | DEFINITIONS ::= | |
51052 | BEGIN | |
51053 | BERPDU ::= OBJECT IDENTIFIER | |
51054 | b BERPDU ::= {joint-iso-itu-t 100 a(2) b(3)} | |
51055 | ||
51056 | END | |
51057 | ||
51058 | <STATIC> | |
51059 | ||
51060 | import from TempA all; | |
51061 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
51062 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
51063 | ||
51064 | ||
51065 | ||
51066 | <TTCN_TC:EXEC> | |
51067 | ||
51068 | if ((enc_DER_PDU(b) == '060481340203'O)and(enc_CER_PDU(b) == '060481340203'O)) {setverdict(pass);} else {setverdict(fail);} | |
51069 | ||
51070 | <RESULT> | |
51071 | ||
51072 | Overall verdict: pass | |
51073 | ||
51074 | <END_TC> | |
51075 | ||
51076 | :exmp. | |
51077 | ||
51078 | .*---------------------------------------------------------------------* | |
51079 | :h3.CER + DER encoding of OBJECT IDENTIFIER , 2 100 (primitive) | |
51080 | .*---------------------------------------------------------------------* | |
51081 | :xmp tab=0. | |
51082 | ||
51083 | <TC - CER + DER encoding of OBJECT IDENTIFIER , 2 100 (primitive)> | |
51084 | ||
51085 | <STATIC:ASN> | |
51086 | ||
51087 | TempA | |
51088 | ||
51089 | DEFINITIONS ::= | |
51090 | BEGIN | |
51091 | BERPDU ::= OBJECT IDENTIFIER | |
51092 | b BERPDU ::= {2 100 a(2) b(3)} | |
51093 | ||
51094 | END | |
51095 | ||
51096 | <STATIC> | |
51097 | ||
51098 | import from TempA all; | |
51099 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
51100 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
51101 | ||
51102 | ||
51103 | ||
51104 | <TTCN_TC:EXEC> | |
51105 | ||
51106 | if ((enc_DER_PDU(b) == '060481340203'O)and(enc_CER_PDU(b) == '060481340203'O)) {setverdict(pass);} else {setverdict(fail);} | |
51107 | ||
51108 | <RESULT> | |
51109 | ||
51110 | Overall verdict: pass | |
51111 | ||
51112 | <END_TC> | |
51113 | ||
51114 | :exmp. | |
51115 | ||
51116 | .*---------------------------------------------------------------------* | |
51117 | :h3.CER + DER encoding of OBJECT IDENTIFIER , multiple octets needed for values (primitive) | |
51118 | .*---------------------------------------------------------------------* | |
51119 | :xmp tab=0. | |
51120 | ||
51121 | <TC - CER + DER encoding of OBJECT IDENTIFIER , multiple octets needed for values (primitive)> | |
51122 | ||
51123 | <STATIC:ASN> | |
51124 | ||
51125 | TempA | |
51126 | ||
51127 | DEFINITIONS ::= | |
51128 | BEGIN | |
51129 | BERPDU ::= OBJECT IDENTIFIER | |
51130 | b BERPDU ::= {joint-iso-itu-t(2) something(0) a(2) b(3) 2000 4000 } | |
51131 | ||
51132 | END | |
51133 | ||
51134 | <STATIC> | |
51135 | ||
51136 | import from TempA all; | |
51137 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
51138 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
51139 | ||
51140 | ||
51141 | ||
51142 | <TTCN_TC:EXEC> | |
51143 | ||
51144 | if ((enc_DER_PDU(b) == '06075002038F509F20'O)and(enc_CER_PDU(b) == '06075002038F509F20'O)) {setverdict(pass);} else {setverdict(fail);} | |
51145 | ||
51146 | <RESULT> | |
51147 | ||
51148 | Overall verdict: pass | |
51149 | ||
51150 | <END_TC> | |
51151 | ||
51152 | :exmp. | |
51153 | ||
51154 | .*---------------------------------------------------------------------* | |
51155 | :h3.CER + DER encoding of OBJECT IDENTIFIER , [0] IMPLICIT, primitive | |
51156 | .*---------------------------------------------------------------------* | |
51157 | :xmp tab=0. | |
51158 | ||
51159 | <TC - CER + DER encoding of OBJECT IDENTIFIER , [0] IMPLICIT, primitive> | |
51160 | ||
51161 | <STATIC:ASN> | |
51162 | ||
51163 | TempA | |
51164 | ||
51165 | DEFINITIONS ::= | |
51166 | BEGIN | |
51167 | BERPDU ::= [0] IMPLICIT OBJECT IDENTIFIER | |
51168 | b BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
51169 | ||
51170 | END | |
51171 | ||
51172 | <STATIC> | |
51173 | ||
51174 | import from TempA all; | |
51175 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
51176 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
51177 | ||
51178 | ||
51179 | ||
51180 | <TTCN_TC:EXEC> | |
51181 | ||
51182 | if ((enc_DER_PDU(b) == '8003000203'O)and(enc_CER_PDU(b) == '8003000203'O)) {setverdict(pass);} else {setverdict(fail);} | |
51183 | ||
51184 | <RESULT> | |
51185 | ||
51186 | Overall verdict: pass | |
51187 | ||
51188 | <END_TC> | |
51189 | ||
51190 | :exmp. | |
51191 | ||
51192 | .*---------------------------------------------------------------------* | |
51193 | :h3.CER + DER encoding of OBJECT IDENTIFIER , [0] EXPLICIT constructed | |
51194 | .*---------------------------------------------------------------------* | |
51195 | :xmp tab=0. | |
51196 | ||
51197 | <TC - CER + DER encoding of OBJECT IDENTIFIER , [0] EXPLICIT constructed> | |
51198 | ||
51199 | <STATIC:ASN> | |
51200 | ||
51201 | TempA | |
51202 | ||
51203 | DEFINITIONS ::= | |
51204 | BEGIN | |
51205 | BERPDU ::= [0] EXPLICIT OBJECT IDENTIFIER | |
51206 | b BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
51207 | ||
51208 | END | |
51209 | ||
51210 | <STATIC> | |
51211 | ||
51212 | import from TempA all; | |
51213 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
51214 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
51215 | ||
51216 | ||
51217 | ||
51218 | <TTCN_TC:EXEC> | |
51219 | ||
51220 | if ((enc_DER_PDU(b) == 'A0050603000203'O)and(enc_CER_PDU(b) == 'A08006030002030000'O)) {setverdict(pass);} else {setverdict(fail);} | |
51221 | ||
51222 | <RESULT> | |
51223 | ||
51224 | Overall verdict: pass | |
51225 | ||
51226 | <END_TC> | |
51227 | ||
51228 | :exmp. | |
51229 | ||
51230 | .*---------------------------------------------------------------------* | |
51231 | :h3. DECODING OBJECT IDENTIFIER , CER+DER, itu-t(0) recommendation(0) ,(primitive) | |
51232 | .*---------------------------------------------------------------------* | |
51233 | :xmp tab=0. | |
51234 | ||
51235 | <TC - DECODING OBJECT IDENTIFIER , CER+DER, itu-t(0) recommendation(0) ,(primitive)> | |
51236 | ||
51237 | <STATIC:ASN> | |
51238 | ||
51239 | TempA | |
51240 | ||
51241 | DEFINITIONS ::= | |
51242 | BEGIN | |
51243 | BERPDU ::= OBJECT IDENTIFIER | |
51244 | ||
51245 | myValue BERPDU ::= { itu-t(0) recommendation(0) a(2) b(3)} | |
51246 | ||
51247 | END | |
51248 | ||
51249 | <STATIC> | |
51250 | ||
51251 | import from TempA all; | |
51252 | ||
51253 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51254 | ||
51255 | ||
51256 | <TTCN_TC:EXEC> | |
51257 | ||
51258 | if (dec_BER_PDU('0603000203'O) == myValue) | |
51259 | ||
51260 | ||
51261 | {setverdict(pass);} else {setverdict(fail);} | |
51262 | ||
51263 | ||
51264 | <RESULT> | |
51265 | ||
51266 | Overall verdict: pass | |
51267 | ||
51268 | <END_TC> | |
51269 | ||
51270 | :exmp. | |
51271 | ||
51272 | .*---------------------------------------------------------------------* | |
51273 | :h3. DECODING OBJECT IDENTIFIER , CER+DER, itu-t recommendation ,(primitive) | |
51274 | .*---------------------------------------------------------------------* | |
51275 | :xmp tab=0. | |
51276 | ||
51277 | <TC - DECODING OBJECT IDENTIFIER , CER+DER, itu-t recommendation ,(primitive)> | |
51278 | ||
51279 | <STATIC:ASN> | |
51280 | ||
51281 | TempA | |
51282 | ||
51283 | DEFINITIONS ::= | |
51284 | BEGIN | |
51285 | BERPDU ::= OBJECT IDENTIFIER | |
51286 | ||
51287 | myValue BERPDU ::= {itu-t recommendation a(2) b(3)} | |
51288 | ||
51289 | END | |
51290 | ||
51291 | <STATIC> | |
51292 | ||
51293 | import from TempA all; | |
51294 | ||
51295 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51296 | ||
51297 | ||
51298 | <TTCN_TC:EXEC> | |
51299 | ||
51300 | if (dec_BER_PDU('0603000203'O) == myValue) | |
51301 | ||
51302 | ||
51303 | {setverdict(pass);} else {setverdict(fail);} | |
51304 | ||
51305 | ||
51306 | <RESULT> | |
51307 | ||
51308 | Overall verdict: pass | |
51309 | ||
51310 | <END_TC> | |
51311 | ||
51312 | :exmp. | |
51313 | ||
51314 | .*---------------------------------------------------------------------* | |
51315 | :h3. DECODING OBJECT IDENTIFIER , CER+DER 0 0 ,(primitive) | |
51316 | .*---------------------------------------------------------------------* | |
51317 | :xmp tab=0. | |
51318 | ||
51319 | <TC - DECODING OBJECT IDENTIFIER , CER+DER 0 0 ,(primitive)> | |
51320 | ||
51321 | <STATIC:ASN> | |
51322 | ||
51323 | TempA | |
51324 | ||
51325 | DEFINITIONS ::= | |
51326 | BEGIN | |
51327 | BERPDU ::= OBJECT IDENTIFIER | |
51328 | ||
51329 | myValue BERPDU ::= {0 0 a(2) b(3)} | |
51330 | ||
51331 | END | |
51332 | ||
51333 | <STATIC> | |
51334 | ||
51335 | import from TempA all; | |
51336 | ||
51337 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51338 | ||
51339 | ||
51340 | <TTCN_TC:EXEC> | |
51341 | ||
51342 | if (dec_BER_PDU('0603000203'O) == myValue) | |
51343 | ||
51344 | ||
51345 | {setverdict(pass);} else {setverdict(fail);} | |
51346 | ||
51347 | ||
51348 | <RESULT> | |
51349 | ||
51350 | Overall verdict: pass | |
51351 | ||
51352 | <END_TC> | |
51353 | ||
51354 | :exmp. | |
51355 | ||
51356 | .*---------------------------------------------------------------------* | |
51357 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) question(1) ,(primitive) | |
51358 | .*---------------------------------------------------------------------* | |
51359 | :xmp tab=0. | |
51360 | ||
51361 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) question(1) ,(primitive)> | |
51362 | ||
51363 | <STATIC:ASN> | |
51364 | ||
51365 | TempA | |
51366 | ||
51367 | DEFINITIONS ::= | |
51368 | BEGIN | |
51369 | BERPDU ::= OBJECT IDENTIFIER | |
51370 | ||
51371 | myValue BERPDU ::= {itu-t(0) question(1) a(2) b(3)} | |
51372 | ||
51373 | END | |
51374 | ||
51375 | <STATIC> | |
51376 | ||
51377 | import from TempA all; | |
51378 | ||
51379 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51380 | ||
51381 | ||
51382 | <TTCN_TC:EXEC> | |
51383 | ||
51384 | if (dec_BER_PDU('0603010203'O) == myValue) | |
51385 | ||
51386 | ||
51387 | {setverdict(pass);} else {setverdict(fail);} | |
51388 | ||
51389 | ||
51390 | <RESULT> | |
51391 | ||
51392 | Overall verdict: pass | |
51393 | ||
51394 | <END_TC> | |
51395 | ||
51396 | :exmp. | |
51397 | ||
51398 | .*---------------------------------------------------------------------* | |
51399 | :h3. DECODING OBJECT IDENTIFIER , CER+DER, itu-t question ,(primitive) | |
51400 | .*---------------------------------------------------------------------* | |
51401 | :xmp tab=0. | |
51402 | ||
51403 | <TC - DECODING OBJECT IDENTIFIER , CER+DER, itu-t question ,(primitive)> | |
51404 | ||
51405 | <STATIC:ASN> | |
51406 | ||
51407 | TempA | |
51408 | ||
51409 | DEFINITIONS ::= | |
51410 | BEGIN | |
51411 | BERPDU ::= OBJECT IDENTIFIER | |
51412 | ||
51413 | myValue BERPDU ::= {itu-t question a(2) b(3)} | |
51414 | ||
51415 | END | |
51416 | ||
51417 | <STATIC> | |
51418 | ||
51419 | import from TempA all; | |
51420 | ||
51421 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51422 | ||
51423 | ||
51424 | <TTCN_TC:EXEC> | |
51425 | ||
51426 | if (dec_BER_PDU('0603010203'O) == myValue) | |
51427 | ||
51428 | ||
51429 | {setverdict(pass);} else {setverdict(fail);} | |
51430 | ||
51431 | ||
51432 | <RESULT> | |
51433 | ||
51434 | Overall verdict: pass | |
51435 | ||
51436 | <END_TC> | |
51437 | ||
51438 | :exmp. | |
51439 | ||
51440 | .*---------------------------------------------------------------------* | |
51441 | :h3. DECODING OBJECT IDENTIFIER , CER+DER 0 1 ,(primitive) | |
51442 | .*---------------------------------------------------------------------* | |
51443 | :xmp tab=0. | |
51444 | ||
51445 | <TC - DECODING OBJECT IDENTIFIER , CER+DER 0 1 ,(primitive)> | |
51446 | ||
51447 | <STATIC:ASN> | |
51448 | ||
51449 | TempA | |
51450 | ||
51451 | DEFINITIONS ::= | |
51452 | BEGIN | |
51453 | BERPDU ::= OBJECT IDENTIFIER | |
51454 | ||
51455 | myValue BERPDU ::= {0 1 a(2) b(3)} | |
51456 | ||
51457 | END | |
51458 | ||
51459 | <STATIC> | |
51460 | ||
51461 | import from TempA all; | |
51462 | ||
51463 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51464 | ||
51465 | ||
51466 | <TTCN_TC:EXEC> | |
51467 | ||
51468 | if (dec_BER_PDU('0603010203'O) == myValue) | |
51469 | ||
51470 | ||
51471 | {setverdict(pass);} else {setverdict(fail);} | |
51472 | ||
51473 | ||
51474 | <RESULT> | |
51475 | ||
51476 | Overall verdict: pass | |
51477 | ||
51478 | <END_TC> | |
51479 | ||
51480 | :exmp. | |
51481 | ||
51482 | .*---------------------------------------------------------------------* | |
51483 | :h3. DECODING OBJECT IDENTIFIER , CER+DER , itu-t(0) administration(2) ,(primitive) | |
51484 | .*---------------------------------------------------------------------* | |
51485 | :xmp tab=0. | |
51486 | ||
51487 | <TC - DECODING OBJECT IDENTIFIER , CER+DER , itu-t(0) administration(2) ,(primitive)> | |
51488 | ||
51489 | <STATIC:ASN> | |
51490 | ||
51491 | TempA | |
51492 | ||
51493 | DEFINITIONS ::= | |
51494 | BEGIN | |
51495 | BERPDU ::= OBJECT IDENTIFIER | |
51496 | ||
51497 | myValue BERPDU ::= {itu-t(0) administration(2) a(2) b(3)} | |
51498 | ||
51499 | END | |
51500 | ||
51501 | <STATIC> | |
51502 | ||
51503 | import from TempA all; | |
51504 | ||
51505 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51506 | ||
51507 | ||
51508 | <TTCN_TC:EXEC> | |
51509 | ||
51510 | if (dec_BER_PDU('0603020203'O) == myValue) | |
51511 | ||
51512 | ||
51513 | {setverdict(pass);} else {setverdict(fail);} | |
51514 | ||
51515 | ||
51516 | <RESULT> | |
51517 | ||
51518 | Overall verdict: pass | |
51519 | ||
51520 | <END_TC> | |
51521 | ||
51522 | :exmp. | |
51523 | ||
51524 | .*---------------------------------------------------------------------* | |
51525 | :h3. DECODING OBJECT IDENTIFIER , CER+DER , itu-t administration ,(primitive) | |
51526 | .*---------------------------------------------------------------------* | |
51527 | :xmp tab=0. | |
51528 | ||
51529 | <TC - DECODING OBJECT IDENTIFIER , CER+DER , itu-t administration ,(primitive)> | |
51530 | ||
51531 | <STATIC:ASN> | |
51532 | ||
51533 | TempA | |
51534 | ||
51535 | DEFINITIONS ::= | |
51536 | BEGIN | |
51537 | BERPDU ::= OBJECT IDENTIFIER | |
51538 | ||
51539 | myValue BERPDU ::= {itu-t administration a(2) b(3)} | |
51540 | ||
51541 | END | |
51542 | ||
51543 | <STATIC> | |
51544 | ||
51545 | import from TempA all; | |
51546 | ||
51547 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51548 | ||
51549 | ||
51550 | <TTCN_TC:EXEC> | |
51551 | ||
51552 | if (dec_BER_PDU('0603020203'O) == myValue) | |
51553 | ||
51554 | ||
51555 | {setverdict(pass);} else {setverdict(fail);} | |
51556 | ||
51557 | ||
51558 | <RESULT> | |
51559 | ||
51560 | Overall verdict: pass | |
51561 | ||
51562 | <END_TC> | |
51563 | ||
51564 | :exmp. | |
51565 | ||
51566 | .*---------------------------------------------------------------------* | |
51567 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,0 2 ,(primitive) | |
51568 | .*---------------------------------------------------------------------* | |
51569 | :xmp tab=0. | |
51570 | ||
51571 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,0 2 ,(primitive)> | |
51572 | ||
51573 | <STATIC:ASN> | |
51574 | ||
51575 | TempA | |
51576 | ||
51577 | DEFINITIONS ::= | |
51578 | BEGIN | |
51579 | BERPDU ::= OBJECT IDENTIFIER | |
51580 | ||
51581 | myValue BERPDU ::= {0 2 a(2) b(3)} | |
51582 | ||
51583 | END | |
51584 | ||
51585 | <STATIC> | |
51586 | ||
51587 | import from TempA all; | |
51588 | ||
51589 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51590 | ||
51591 | ||
51592 | <TTCN_TC:EXEC> | |
51593 | ||
51594 | if (dec_BER_PDU('0603020203'O) == myValue) | |
51595 | ||
51596 | ||
51597 | {setverdict(pass);} else {setverdict(fail);} | |
51598 | ||
51599 | ||
51600 | <RESULT> | |
51601 | ||
51602 | Overall verdict: pass | |
51603 | ||
51604 | <END_TC> | |
51605 | ||
51606 | :exmp. | |
51607 | ||
51608 | .*---------------------------------------------------------------------* | |
51609 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) network-operator(3) ,(primitive) | |
51610 | .*---------------------------------------------------------------------* | |
51611 | :xmp tab=0. | |
51612 | ||
51613 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) network-operator(3) ,(primitive)> | |
51614 | ||
51615 | <STATIC:ASN> | |
51616 | ||
51617 | TempA | |
51618 | ||
51619 | DEFINITIONS ::= | |
51620 | BEGIN | |
51621 | BERPDU ::= OBJECT IDENTIFIER | |
51622 | ||
51623 | myValue BERPDU ::= {itu-t(0) network-operator(3) a(2) b(3)} | |
51624 | ||
51625 | END | |
51626 | ||
51627 | <STATIC> | |
51628 | ||
51629 | import from TempA all; | |
51630 | ||
51631 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51632 | ||
51633 | ||
51634 | <TTCN_TC:EXEC> | |
51635 | ||
51636 | if (dec_BER_PDU('0603030203'O) == myValue) | |
51637 | ||
51638 | ||
51639 | {setverdict(pass);} else {setverdict(fail);} | |
51640 | ||
51641 | ||
51642 | <RESULT> | |
51643 | ||
51644 | Overall verdict: pass | |
51645 | ||
51646 | <END_TC> | |
51647 | ||
51648 | :exmp. | |
51649 | ||
51650 | .*---------------------------------------------------------------------* | |
51651 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t network-operator ,(primitive) | |
51652 | .*---------------------------------------------------------------------* | |
51653 | :xmp tab=0. | |
51654 | ||
51655 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t network-operator ,(primitive)> | |
51656 | ||
51657 | <STATIC:ASN> | |
51658 | ||
51659 | TempA | |
51660 | ||
51661 | DEFINITIONS ::= | |
51662 | BEGIN | |
51663 | BERPDU ::= OBJECT IDENTIFIER | |
51664 | ||
51665 | myValue BERPDU ::= {itu-t network-operator a(2) b(3)} | |
51666 | ||
51667 | END | |
51668 | ||
51669 | <STATIC> | |
51670 | ||
51671 | import from TempA all; | |
51672 | ||
51673 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51674 | ||
51675 | ||
51676 | <TTCN_TC:EXEC> | |
51677 | ||
51678 | if (dec_BER_PDU('0603030203'O) == myValue) | |
51679 | ||
51680 | ||
51681 | {setverdict(pass);} else {setverdict(fail);} | |
51682 | ||
51683 | ||
51684 | <RESULT> | |
51685 | ||
51686 | Overall verdict: pass | |
51687 | ||
51688 | <END_TC> | |
51689 | ||
51690 | :exmp. | |
51691 | ||
51692 | .*---------------------------------------------------------------------* | |
51693 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,0 3 ,(primitive) | |
51694 | .*---------------------------------------------------------------------* | |
51695 | :xmp tab=0. | |
51696 | ||
51697 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,0 3 ,(primitive)> | |
51698 | ||
51699 | <STATIC:ASN> | |
51700 | ||
51701 | TempA | |
51702 | ||
51703 | DEFINITIONS ::= | |
51704 | BEGIN | |
51705 | BERPDU ::= OBJECT IDENTIFIER | |
51706 | ||
51707 | myValue BERPDU ::= {0 3 a(2) b(3)} | |
51708 | ||
51709 | END | |
51710 | ||
51711 | <STATIC> | |
51712 | ||
51713 | import from TempA all; | |
51714 | ||
51715 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51716 | ||
51717 | ||
51718 | <TTCN_TC:EXEC> | |
51719 | ||
51720 | if (dec_BER_PDU('0603030203'O) == myValue) | |
51721 | ||
51722 | ||
51723 | {setverdict(pass);} else {setverdict(fail);} | |
51724 | ||
51725 | ||
51726 | <RESULT> | |
51727 | ||
51728 | Overall verdict: pass | |
51729 | ||
51730 | <END_TC> | |
51731 | ||
51732 | :exmp. | |
51733 | ||
51734 | .*---------------------------------------------------------------------* | |
51735 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) identified-organization(4) ,(primitive) | |
51736 | .*---------------------------------------------------------------------* | |
51737 | :xmp tab=0. | |
51738 | ||
51739 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t(0) identified-organization(4) ,(primitive)> | |
51740 | ||
51741 | <STATIC:ASN> | |
51742 | ||
51743 | TempA | |
51744 | ||
51745 | DEFINITIONS ::= | |
51746 | BEGIN | |
51747 | BERPDU ::= OBJECT IDENTIFIER | |
51748 | ||
51749 | myValue BERPDU ::= {itu-t(0) identified-organization(4) a(2) b(3)} | |
51750 | ||
51751 | END | |
51752 | ||
51753 | <STATIC> | |
51754 | ||
51755 | import from TempA all; | |
51756 | ||
51757 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51758 | ||
51759 | ||
51760 | <TTCN_TC:EXEC> | |
51761 | ||
51762 | if (dec_BER_PDU('0603040203'O) == myValue) | |
51763 | ||
51764 | ||
51765 | {setverdict(pass);} else {setverdict(fail);} | |
51766 | ||
51767 | ||
51768 | <RESULT> | |
51769 | ||
51770 | Overall verdict: pass | |
51771 | ||
51772 | <END_TC> | |
51773 | ||
51774 | :exmp. | |
51775 | ||
51776 | .*---------------------------------------------------------------------* | |
51777 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,itu-t identified-organization ,(primitive) | |
51778 | .*---------------------------------------------------------------------* | |
51779 | :xmp tab=0. | |
51780 | ||
51781 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,itu-t identified-organization ,(primitive)> | |
51782 | ||
51783 | <STATIC:ASN> | |
51784 | ||
51785 | TempA | |
51786 | ||
51787 | DEFINITIONS ::= | |
51788 | BEGIN | |
51789 | BERPDU ::= OBJECT IDENTIFIER | |
51790 | ||
51791 | myValue BERPDU ::= {itu-t identified-organization a(2) b(3)} | |
51792 | ||
51793 | END | |
51794 | ||
51795 | <STATIC> | |
51796 | ||
51797 | import from TempA all; | |
51798 | ||
51799 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51800 | ||
51801 | ||
51802 | <TTCN_TC:EXEC> | |
51803 | ||
51804 | if (dec_BER_PDU('0603040203'O) == myValue) | |
51805 | ||
51806 | ||
51807 | {setverdict(pass);} else {setverdict(fail);} | |
51808 | ||
51809 | ||
51810 | <RESULT> | |
51811 | ||
51812 | Overall verdict: pass | |
51813 | ||
51814 | <END_TC> | |
51815 | ||
51816 | :exmp. | |
51817 | ||
51818 | .*---------------------------------------------------------------------* | |
51819 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,0 4 ,(primitive) | |
51820 | .*---------------------------------------------------------------------* | |
51821 | :xmp tab=0. | |
51822 | ||
51823 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,0 4 ,(primitive)> | |
51824 | ||
51825 | <STATIC:ASN> | |
51826 | ||
51827 | TempA | |
51828 | ||
51829 | DEFINITIONS ::= | |
51830 | BEGIN | |
51831 | BERPDU ::= OBJECT IDENTIFIER | |
51832 | ||
51833 | myValue BERPDU ::= {0 4 a(2) b(3)} | |
51834 | ||
51835 | END | |
51836 | ||
51837 | <STATIC> | |
51838 | ||
51839 | import from TempA all; | |
51840 | ||
51841 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51842 | ||
51843 | ||
51844 | <TTCN_TC:EXEC> | |
51845 | ||
51846 | if (dec_BER_PDU('0603040203'O) == myValue) | |
51847 | ||
51848 | ||
51849 | {setverdict(pass);} else {setverdict(fail);} | |
51850 | ||
51851 | ||
51852 | <RESULT> | |
51853 | ||
51854 | Overall verdict: pass | |
51855 | ||
51856 | <END_TC> | |
51857 | ||
51858 | :exmp. | |
51859 | ||
51860 | .*---------------------------------------------------------------------* | |
51861 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) standard(0) ,(primitive) | |
51862 | .*---------------------------------------------------------------------* | |
51863 | :xmp tab=0. | |
51864 | ||
51865 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) standard(0) ,(primitive)> | |
51866 | ||
51867 | <STATIC:ASN> | |
51868 | ||
51869 | TempA | |
51870 | ||
51871 | DEFINITIONS ::= | |
51872 | BEGIN | |
51873 | BERPDU ::= OBJECT IDENTIFIER | |
51874 | ||
51875 | myValue BERPDU ::= {iso(1) standard(0) a(2) b(3)} | |
51876 | ||
51877 | END | |
51878 | ||
51879 | <STATIC> | |
51880 | ||
51881 | import from TempA all; | |
51882 | ||
51883 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51884 | ||
51885 | ||
51886 | <TTCN_TC:EXEC> | |
51887 | ||
51888 | if (dec_BER_PDU('0603280203'O) == myValue) | |
51889 | ||
51890 | ||
51891 | {setverdict(pass);} else {setverdict(fail);} | |
51892 | ||
51893 | ||
51894 | <RESULT> | |
51895 | ||
51896 | Overall verdict: pass | |
51897 | ||
51898 | <END_TC> | |
51899 | ||
51900 | :exmp. | |
51901 | ||
51902 | .*---------------------------------------------------------------------* | |
51903 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso standard ,(primitive) | |
51904 | .*---------------------------------------------------------------------* | |
51905 | :xmp tab=0. | |
51906 | ||
51907 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso standard ,(primitive)> | |
51908 | ||
51909 | <STATIC:ASN> | |
51910 | ||
51911 | TempA | |
51912 | ||
51913 | DEFINITIONS ::= | |
51914 | BEGIN | |
51915 | BERPDU ::= OBJECT IDENTIFIER | |
51916 | ||
51917 | myValue BERPDU ::= {iso standard a(2) b(3)} | |
51918 | ||
51919 | END | |
51920 | ||
51921 | <STATIC> | |
51922 | ||
51923 | import from TempA all; | |
51924 | ||
51925 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51926 | ||
51927 | ||
51928 | <TTCN_TC:EXEC> | |
51929 | ||
51930 | if (dec_BER_PDU('0603280203'O) == myValue) | |
51931 | ||
51932 | ||
51933 | {setverdict(pass);} else {setverdict(fail);} | |
51934 | ||
51935 | ||
51936 | <RESULT> | |
51937 | ||
51938 | Overall verdict: pass | |
51939 | ||
51940 | <END_TC> | |
51941 | ||
51942 | :exmp. | |
51943 | ||
51944 | .*---------------------------------------------------------------------* | |
51945 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,1 0 ,(primitive) | |
51946 | .*---------------------------------------------------------------------* | |
51947 | :xmp tab=0. | |
51948 | ||
51949 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,1 0 ,(primitive)> | |
51950 | ||
51951 | <STATIC:ASN> | |
51952 | ||
51953 | TempA | |
51954 | ||
51955 | DEFINITIONS ::= | |
51956 | BEGIN | |
51957 | BERPDU ::= OBJECT IDENTIFIER | |
51958 | ||
51959 | myValue BERPDU ::= {1 0 a(2) b(3)} | |
51960 | ||
51961 | END | |
51962 | ||
51963 | <STATIC> | |
51964 | ||
51965 | import from TempA all; | |
51966 | ||
51967 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
51968 | ||
51969 | ||
51970 | <TTCN_TC:EXEC> | |
51971 | ||
51972 | if (dec_BER_PDU('0603280203'O) == myValue) | |
51973 | ||
51974 | ||
51975 | {setverdict(pass);} else {setverdict(fail);} | |
51976 | ||
51977 | ||
51978 | <RESULT> | |
51979 | ||
51980 | Overall verdict: pass | |
51981 | ||
51982 | <END_TC> | |
51983 | ||
51984 | :exmp. | |
51985 | ||
51986 | .*---------------------------------------------------------------------* | |
51987 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) member-body(2) ,(primitive) | |
51988 | .*---------------------------------------------------------------------* | |
51989 | :xmp tab=0. | |
51990 | ||
51991 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) member-body(2) ,(primitive)> | |
51992 | ||
51993 | <STATIC:ASN> | |
51994 | ||
51995 | TempA | |
51996 | ||
51997 | DEFINITIONS ::= | |
51998 | BEGIN | |
51999 | BERPDU ::= OBJECT IDENTIFIER | |
52000 | ||
52001 | myValue BERPDU ::= {iso(1) member-body(2) a(2) b(3)} | |
52002 | ||
52003 | END | |
52004 | ||
52005 | <STATIC> | |
52006 | ||
52007 | import from TempA all; | |
52008 | ||
52009 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52010 | ||
52011 | ||
52012 | <TTCN_TC:EXEC> | |
52013 | ||
52014 | if (dec_BER_PDU('06032A0203'O) == myValue) | |
52015 | ||
52016 | ||
52017 | {setverdict(pass);} else {setverdict(fail);} | |
52018 | ||
52019 | ||
52020 | <RESULT> | |
52021 | ||
52022 | Overall verdict: pass | |
52023 | ||
52024 | <END_TC> | |
52025 | ||
52026 | :exmp. | |
52027 | ||
52028 | .*---------------------------------------------------------------------* | |
52029 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso member-body ,(primitive) | |
52030 | .*---------------------------------------------------------------------* | |
52031 | :xmp tab=0. | |
52032 | ||
52033 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso member-body ,(primitive)> | |
52034 | ||
52035 | <STATIC:ASN> | |
52036 | ||
52037 | TempA | |
52038 | ||
52039 | DEFINITIONS ::= | |
52040 | BEGIN | |
52041 | BERPDU ::= OBJECT IDENTIFIER | |
52042 | ||
52043 | myValue BERPDU ::= {iso member-body a(2) b(3)} | |
52044 | ||
52045 | END | |
52046 | ||
52047 | <STATIC> | |
52048 | ||
52049 | import from TempA all; | |
52050 | ||
52051 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52052 | ||
52053 | ||
52054 | <TTCN_TC:EXEC> | |
52055 | ||
52056 | if (dec_BER_PDU('06032A0203'O) == myValue) | |
52057 | ||
52058 | ||
52059 | {setverdict(pass);} else {setverdict(fail);} | |
52060 | ||
52061 | ||
52062 | <RESULT> | |
52063 | ||
52064 | Overall verdict: pass | |
52065 | ||
52066 | <END_TC> | |
52067 | ||
52068 | :exmp. | |
52069 | ||
52070 | .*---------------------------------------------------------------------* | |
52071 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,1 2 ,(primitive) | |
52072 | .*---------------------------------------------------------------------* | |
52073 | :xmp tab=0. | |
52074 | ||
52075 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,1 2 ,(primitive)> | |
52076 | ||
52077 | <STATIC:ASN> | |
52078 | ||
52079 | TempA | |
52080 | ||
52081 | DEFINITIONS ::= | |
52082 | BEGIN | |
52083 | BERPDU ::= OBJECT IDENTIFIER | |
52084 | ||
52085 | myValue BERPDU ::= {1 2 a(2) b(3)} | |
52086 | ||
52087 | END | |
52088 | ||
52089 | <STATIC> | |
52090 | ||
52091 | import from TempA all; | |
52092 | ||
52093 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52094 | ||
52095 | ||
52096 | <TTCN_TC:EXEC> | |
52097 | ||
52098 | if (dec_BER_PDU('06032A0203'O) == myValue) | |
52099 | ||
52100 | ||
52101 | {setverdict(pass);} else {setverdict(fail);} | |
52102 | ||
52103 | ||
52104 | <RESULT> | |
52105 | ||
52106 | Overall verdict: pass | |
52107 | ||
52108 | <END_TC> | |
52109 | ||
52110 | :exmp. | |
52111 | ||
52112 | .*---------------------------------------------------------------------* | |
52113 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) identified-organization(3) ,(primitive) | |
52114 | .*---------------------------------------------------------------------* | |
52115 | :xmp tab=0. | |
52116 | ||
52117 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso(1) identified-organization(3) ,(primitive)> | |
52118 | ||
52119 | <STATIC:ASN> | |
52120 | ||
52121 | TempA | |
52122 | ||
52123 | DEFINITIONS ::= | |
52124 | BEGIN | |
52125 | BERPDU ::= OBJECT IDENTIFIER | |
52126 | ||
52127 | myValue BERPDU ::= {iso(1) identified-organization(3) a(2) b(3)} | |
52128 | ||
52129 | END | |
52130 | ||
52131 | <STATIC> | |
52132 | ||
52133 | import from TempA all; | |
52134 | ||
52135 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52136 | ||
52137 | ||
52138 | <TTCN_TC:EXEC> | |
52139 | ||
52140 | if (dec_BER_PDU('06032B0203'O) == myValue) | |
52141 | ||
52142 | ||
52143 | {setverdict(pass);} else {setverdict(fail);} | |
52144 | ||
52145 | ||
52146 | <RESULT> | |
52147 | ||
52148 | Overall verdict: pass | |
52149 | ||
52150 | <END_TC> | |
52151 | ||
52152 | :exmp. | |
52153 | ||
52154 | .*---------------------------------------------------------------------* | |
52155 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,iso identified-organization ,(primitive) | |
52156 | .*---------------------------------------------------------------------* | |
52157 | :xmp tab=0. | |
52158 | ||
52159 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,iso identified-organization ,(primitive)> | |
52160 | ||
52161 | <STATIC:ASN> | |
52162 | ||
52163 | TempA | |
52164 | ||
52165 | DEFINITIONS ::= | |
52166 | BEGIN | |
52167 | BERPDU ::= OBJECT IDENTIFIER | |
52168 | ||
52169 | myValue BERPDU ::= {iso identified-organization a(2) b(3)} | |
52170 | ||
52171 | END | |
52172 | ||
52173 | <STATIC> | |
52174 | ||
52175 | import from TempA all; | |
52176 | ||
52177 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52178 | ||
52179 | ||
52180 | <TTCN_TC:EXEC> | |
52181 | ||
52182 | if (dec_BER_PDU('06032B0203'O) == myValue) | |
52183 | ||
52184 | ||
52185 | {setverdict(pass);} else {setverdict(fail);} | |
52186 | ||
52187 | ||
52188 | <RESULT> | |
52189 | ||
52190 | Overall verdict: pass | |
52191 | ||
52192 | <END_TC> | |
52193 | ||
52194 | :exmp. | |
52195 | ||
52196 | .*---------------------------------------------------------------------* | |
52197 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,1 3 ,(primitive) | |
52198 | .*---------------------------------------------------------------------* | |
52199 | :xmp tab=0. | |
52200 | ||
52201 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,1 3 ,(primitive)> | |
52202 | ||
52203 | <STATIC:ASN> | |
52204 | ||
52205 | TempA | |
52206 | ||
52207 | DEFINITIONS ::= | |
52208 | BEGIN | |
52209 | BERPDU ::= OBJECT IDENTIFIER | |
52210 | ||
52211 | myValue BERPDU ::= {1 3 a(2) b(3)} | |
52212 | ||
52213 | END | |
52214 | ||
52215 | <STATIC> | |
52216 | ||
52217 | import from TempA all; | |
52218 | ||
52219 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52220 | ||
52221 | ||
52222 | <TTCN_TC:EXEC> | |
52223 | ||
52224 | if (dec_BER_PDU('06032B0203'O) == myValue) | |
52225 | ||
52226 | ||
52227 | {setverdict(pass);} else {setverdict(fail);} | |
52228 | ||
52229 | ||
52230 | <RESULT> | |
52231 | ||
52232 | Overall verdict: pass | |
52233 | ||
52234 | <END_TC> | |
52235 | ||
52236 | :exmp. | |
52237 | ||
52238 | .*---------------------------------------------------------------------* | |
52239 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(0) ,(primitive) | |
52240 | .*---------------------------------------------------------------------* | |
52241 | :xmp tab=0. | |
52242 | ||
52243 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(0) ,(primitive)> | |
52244 | ||
52245 | <STATIC:ASN> | |
52246 | ||
52247 | TempA | |
52248 | ||
52249 | DEFINITIONS ::= | |
52250 | BEGIN | |
52251 | BERPDU ::= OBJECT IDENTIFIER | |
52252 | ||
52253 | myValue BERPDU ::= {joint-iso-itu-t(2) something(0) a(2) b(3)} | |
52254 | ||
52255 | END | |
52256 | ||
52257 | <STATIC> | |
52258 | ||
52259 | import from TempA all; | |
52260 | ||
52261 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52262 | ||
52263 | ||
52264 | <TTCN_TC:EXEC> | |
52265 | ||
52266 | if (dec_BER_PDU('0603500203'O) == myValue) | |
52267 | ||
52268 | ||
52269 | {setverdict(pass);} else {setverdict(fail);} | |
52270 | ||
52271 | ||
52272 | <RESULT> | |
52273 | ||
52274 | Overall verdict: pass | |
52275 | ||
52276 | <END_TC> | |
52277 | ||
52278 | :exmp. | |
52279 | ||
52280 | .*---------------------------------------------------------------------* | |
52281 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t something(0) ,(primitive) | |
52282 | .*---------------------------------------------------------------------* | |
52283 | :xmp tab=0. | |
52284 | ||
52285 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t something(0) ,(primitive)> | |
52286 | ||
52287 | <STATIC:ASN> | |
52288 | ||
52289 | TempA | |
52290 | ||
52291 | DEFINITIONS ::= | |
52292 | BEGIN | |
52293 | BERPDU ::= OBJECT IDENTIFIER | |
52294 | ||
52295 | myValue BERPDU ::= {joint-iso-itu-t something(0) a(2) b(3)} | |
52296 | ||
52297 | ||
52298 | END | |
52299 | ||
52300 | <STATIC> | |
52301 | ||
52302 | import from TempA all; | |
52303 | ||
52304 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52305 | ||
52306 | ||
52307 | <TTCN_TC:EXEC> | |
52308 | ||
52309 | if (dec_BER_PDU('0603500203'O) == myValue) | |
52310 | ||
52311 | ||
52312 | {setverdict(pass);} else {setverdict(fail);} | |
52313 | ||
52314 | ||
52315 | <RESULT> | |
52316 | ||
52317 | Overall verdict: pass | |
52318 | ||
52319 | <END_TC> | |
52320 | ||
52321 | :exmp. | |
52322 | ||
52323 | .*---------------------------------------------------------------------* | |
52324 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,2 0 ,(primitive) | |
52325 | .*---------------------------------------------------------------------* | |
52326 | :xmp tab=0. | |
52327 | ||
52328 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,2 0 ,(primitive)> | |
52329 | ||
52330 | <STATIC:ASN> | |
52331 | ||
52332 | TempA | |
52333 | ||
52334 | DEFINITIONS ::= | |
52335 | BEGIN | |
52336 | BERPDU ::= OBJECT IDENTIFIER | |
52337 | ||
52338 | myValue BERPDU ::= {2 0 a(2) b(3)} | |
52339 | ||
52340 | END | |
52341 | ||
52342 | <STATIC> | |
52343 | ||
52344 | import from TempA all; | |
52345 | ||
52346 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52347 | ||
52348 | ||
52349 | <TTCN_TC:EXEC> | |
52350 | ||
52351 | if (dec_BER_PDU('0603500203'O) == myValue) | |
52352 | ||
52353 | ||
52354 | {setverdict(pass);} else {setverdict(fail);} | |
52355 | ||
52356 | ||
52357 | <RESULT> | |
52358 | ||
52359 | Overall verdict: pass | |
52360 | ||
52361 | <END_TC> | |
52362 | ||
52363 | :exmp. | |
52364 | ||
52365 | .*---------------------------------------------------------------------* | |
52366 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(100) ,(primitive) | |
52367 | .*---------------------------------------------------------------------* | |
52368 | :xmp tab=0. | |
52369 | ||
52370 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(100) ,(primitive)> | |
52371 | ||
52372 | <STATIC:ASN> | |
52373 | ||
52374 | TempA | |
52375 | ||
52376 | DEFINITIONS ::= | |
52377 | BEGIN | |
52378 | BERPDU ::= OBJECT IDENTIFIER | |
52379 | ||
52380 | myValue BERPDU ::= {joint-iso-itu-t(2) something(100) a(2) b(3)} | |
52381 | ||
52382 | END | |
52383 | ||
52384 | <STATIC> | |
52385 | ||
52386 | import from TempA all; | |
52387 | ||
52388 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52389 | ||
52390 | ||
52391 | <TTCN_TC:EXEC> | |
52392 | ||
52393 | if (dec_BER_PDU('060481340203'O) == myValue) | |
52394 | ||
52395 | ||
52396 | {setverdict(pass);} else {setverdict(fail);} | |
52397 | ||
52398 | ||
52399 | <RESULT> | |
52400 | ||
52401 | Overall verdict: pass | |
52402 | ||
52403 | <END_TC> | |
52404 | ||
52405 | :exmp. | |
52406 | ||
52407 | .*---------------------------------------------------------------------* | |
52408 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(100) ,(primitive) | |
52409 | .*---------------------------------------------------------------------* | |
52410 | :xmp tab=0. | |
52411 | ||
52412 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,joint-iso-itu-t(2) something(100) ,(primitive)> | |
52413 | ||
52414 | <STATIC:ASN> | |
52415 | ||
52416 | TempA | |
52417 | ||
52418 | DEFINITIONS ::= | |
52419 | BEGIN | |
52420 | BERPDU ::= OBJECT IDENTIFIER | |
52421 | ||
52422 | myValue BERPDU ::= {joint-iso-itu-t 100 a(2) b(3)} | |
52423 | ||
52424 | END | |
52425 | ||
52426 | <STATIC> | |
52427 | ||
52428 | import from TempA all; | |
52429 | ||
52430 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52431 | ||
52432 | ||
52433 | <TTCN_TC:EXEC> | |
52434 | ||
52435 | if (dec_BER_PDU('060481340203'O) == myValue) | |
52436 | ||
52437 | ||
52438 | {setverdict(pass);} else {setverdict(fail);} | |
52439 | ||
52440 | ||
52441 | <RESULT> | |
52442 | ||
52443 | Overall verdict: pass | |
52444 | ||
52445 | <END_TC> | |
52446 | ||
52447 | :exmp. | |
52448 | ||
52449 | .*---------------------------------------------------------------------* | |
52450 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,2 100 ,(primitive) | |
52451 | .*---------------------------------------------------------------------* | |
52452 | :xmp tab=0. | |
52453 | ||
52454 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,2 100 ,(primitive)> | |
52455 | ||
52456 | <STATIC:ASN> | |
52457 | ||
52458 | TempA | |
52459 | ||
52460 | DEFINITIONS ::= | |
52461 | BEGIN | |
52462 | BERPDU ::= OBJECT IDENTIFIER | |
52463 | ||
52464 | myValue BERPDU ::= {2 100 a(2) b(3)} | |
52465 | ||
52466 | END | |
52467 | ||
52468 | <STATIC> | |
52469 | ||
52470 | import from TempA all; | |
52471 | ||
52472 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52473 | ||
52474 | ||
52475 | <TTCN_TC:EXEC> | |
52476 | ||
52477 | if (dec_BER_PDU('060481340203'O) == myValue) | |
52478 | ||
52479 | ||
52480 | {setverdict(pass);} else {setverdict(fail);} | |
52481 | ||
52482 | ||
52483 | <RESULT> | |
52484 | ||
52485 | Overall verdict: pass | |
52486 | ||
52487 | <END_TC> | |
52488 | ||
52489 | :exmp. | |
52490 | ||
52491 | .*---------------------------------------------------------------------* | |
52492 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,multiple octets needed for values ,(primitive) | |
52493 | .*---------------------------------------------------------------------* | |
52494 | :xmp tab=0. | |
52495 | ||
52496 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,multiple octets needed for values ,(primitive)> | |
52497 | ||
52498 | <STATIC:ASN> | |
52499 | ||
52500 | TempA | |
52501 | ||
52502 | DEFINITIONS ::= | |
52503 | BEGIN | |
52504 | BERPDU ::= OBJECT IDENTIFIER | |
52505 | ||
52506 | myValue BERPDU ::= {joint-iso-itu-t(2) something(0) a(2) b(3) 2000 4000 } | |
52507 | ||
52508 | END | |
52509 | ||
52510 | <STATIC> | |
52511 | ||
52512 | import from TempA all; | |
52513 | ||
52514 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52515 | ||
52516 | ||
52517 | <TTCN_TC:EXEC> | |
52518 | ||
52519 | if (dec_BER_PDU('06075002038F509F20'O) == myValue) | |
52520 | ||
52521 | ||
52522 | {setverdict(pass);} else {setverdict(fail);} | |
52523 | ||
52524 | ||
52525 | <RESULT> | |
52526 | ||
52527 | Overall verdict: pass | |
52528 | ||
52529 | <END_TC> | |
52530 | ||
52531 | :exmp. | |
52532 | ||
52533 | .*---------------------------------------------------------------------* | |
52534 | :h3. DECODING OBJECT IDENTIFIER , CER+DER ,0 0, IMPLICIT, primitive | |
52535 | .*---------------------------------------------------------------------* | |
52536 | :xmp tab=0. | |
52537 | ||
52538 | <TC - DECODING OBJECT IDENTIFIER , CER+DER ,0 0, IMPLICIT, primitive> | |
52539 | ||
52540 | <STATIC:ASN> | |
52541 | ||
52542 | TempA | |
52543 | ||
52544 | DEFINITIONS ::= | |
52545 | BEGIN | |
52546 | BERPDU ::= [0] IMPLICIT OBJECT IDENTIFIER | |
52547 | ||
52548 | myValue BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
52549 | ||
52550 | END | |
52551 | ||
52552 | <STATIC> | |
52553 | ||
52554 | import from TempA all; | |
52555 | ||
52556 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52557 | ||
52558 | ||
52559 | <TTCN_TC:EXEC> | |
52560 | ||
52561 | if (dec_BER_PDU('8003000203'O) == myValue) | |
52562 | ||
52563 | ||
52564 | {setverdict(pass);} else {setverdict(fail);} | |
52565 | ||
52566 | ||
52567 | <RESULT> | |
52568 | ||
52569 | Overall verdict: pass | |
52570 | ||
52571 | <END_TC> | |
52572 | ||
52573 | :exmp. | |
52574 | ||
52575 | .*---------------------------------------------------------------------* | |
52576 | :h3. DECODING OBJECT IDENTIFIER , DER ,0 0, EXPLICIT, constructed | |
52577 | .*---------------------------------------------------------------------* | |
52578 | :xmp tab=0. | |
52579 | ||
52580 | <TC - DECODING OBJECT IDENTIFIER , DER ,0 0, EXPLICIT, constructed> | |
52581 | ||
52582 | <STATIC:ASN> | |
52583 | ||
52584 | TempA | |
52585 | ||
52586 | DEFINITIONS ::= | |
52587 | BEGIN | |
52588 | BERPDU ::= [0] EXPLICIT OBJECT IDENTIFIER | |
52589 | ||
52590 | myValue BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
52591 | ||
52592 | END | |
52593 | ||
52594 | <STATIC> | |
52595 | ||
52596 | import from TempA all; | |
52597 | ||
52598 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52599 | ||
52600 | ||
52601 | <TTCN_TC:EXEC> | |
52602 | ||
52603 | if (dec_BER_PDU('A0050603000203'O) == myValue) | |
52604 | ||
52605 | ||
52606 | ||
52607 | {setverdict(pass);} else {setverdict(fail);} | |
52608 | ||
52609 | ||
52610 | <RESULT> | |
52611 | ||
52612 | Overall verdict: pass | |
52613 | ||
52614 | <END_TC> | |
52615 | ||
52616 | :exmp. | |
52617 | ||
52618 | .*---------------------------------------------------------------------* | |
52619 | :h3. DECODING OBJECT IDENTIFIER , CER ,0 0, EXPLICIT, constructed | |
52620 | .*---------------------------------------------------------------------* | |
52621 | :xmp tab=0. | |
52622 | ||
52623 | <TC - DECODING OBJECT IDENTIFIER , CER ,0 0, EXPLICIT, constructed> | |
52624 | ||
52625 | <STATIC:ASN> | |
52626 | ||
52627 | TempA | |
52628 | ||
52629 | DEFINITIONS ::= | |
52630 | BEGIN | |
52631 | BERPDU ::= [0] EXPLICIT OBJECT IDENTIFIER | |
52632 | ||
52633 | myValue BERPDU ::= {itu-t(0) recommendation(0) a(2) b(3)} | |
52634 | ||
52635 | END | |
52636 | ||
52637 | <STATIC> | |
52638 | ||
52639 | import from TempA all; | |
52640 | ||
52641 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52642 | ||
52643 | ||
52644 | <TTCN_TC:EXEC> | |
52645 | ||
52646 | if (dec_BER_PDU('A08006030002030000'O) == myValue) | |
52647 | ||
52648 | {setverdict(pass);} else {setverdict(fail);} | |
52649 | ||
52650 | ||
52651 | <RESULT> | |
52652 | ||
52653 | Overall verdict: pass | |
52654 | ||
52655 | <END_TC> | |
52656 | ||
52657 | :exmp. | |
52658 | ||
52659 | .*---------------------------------------------------------------------* | |
52660 | :h3. CER + DER encoding of OPEN TYPE from Information Object Class | |
52661 | .*---------------------------------------------------------------------* | |
52662 | :xmp tab=0. | |
52663 | ||
52664 | <TC - CER + DER encoding of OPEN TYPE from Information Object Class> | |
52665 | ||
52666 | <STATIC:ASN> | |
52667 | ||
52668 | TempA | |
52669 | ||
52670 | DEFINITIONS ::= | |
52671 | BEGIN | |
52672 | ||
52673 | ||
52674 | --*************************************************************************************************** | |
52675 | --modified class taken from Gyuri ASN1 | |
52676 | --*************************************************************************************************** | |
52677 | MY-CLASS-1 ::= CLASS | |
52678 | { | |
52679 | &TypeField OPTIONAL, | |
52680 | &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL | |
52681 | ||
52682 | } | |
52683 | WITH SYNTAX | |
52684 | { | |
52685 | [TYPE FIELD &TypeField] | |
52686 | [FIXED VALUE TYPE FIELD &fixedTypeValueField] | |
52687 | } | |
52688 | ||
52689 | ASN1-Type1 ::= INTEGER | |
52690 | ||
52691 | ASN1-Type2 ::= BOOLEAN | |
52692 | ||
52693 | ASN1-Type3 ::= SEQUENCE {f1 INTEGER} | |
52694 | ||
52695 | ASN1-Type4 ::= OCTET STRING | |
52696 | ||
52697 | ||
52698 | --**************************************************************************************************** | |
52699 | -- OBJECTS using the class defined above | |
52700 | --**************************************************************************************************** | |
52701 | ||
52702 | ||
52703 | myObject-1 MY-CLASS-1 ::= | |
52704 | { | |
52705 | TYPE FIELD ASN1-Type3 | |
52706 | FIXED VALUE TYPE FIELD 999 | |
52707 | } | |
52708 | ||
52709 | ||
52710 | myObject-2 MY-CLASS-1 ::= | |
52711 | { | |
52712 | TYPE FIELD ASN1-Type2 | |
52713 | FIXED VALUE TYPE FIELD 888 | |
52714 | } | |
52715 | ||
52716 | myObject-3 MY-CLASS-1 ::= | |
52717 | { | |
52718 | TYPE FIELD ASN1-Type4 | |
52719 | FIXED VALUE TYPE FIELD 555 | |
52720 | } | |
52721 | ||
52722 | --**************************************************************************************************** | |
52723 | -- Defining Information Object sets | |
52724 | --**************************************************************************************************** | |
52725 | ||
52726 | MyInformationObjectSet1 MY-CLASS-1 ::= | |
52727 | { | |
52728 | myObject-1| | |
52729 | myObject-2, | |
52730 | ... | |
52731 | } | |
52732 | ||
52733 | MyInformationObjectSet2 MY-CLASS-1 ::= | |
52734 | { | |
52735 | MyInformationObjectSet1| | |
52736 | myObject-3, | |
52737 | ... | |
52738 | } | |
52739 | ||
52740 | BERPDU ::= SEQUENCE | |
52741 | ||
52742 | { | |
52743 | field1 MY-CLASS-1.&TypeField ({MyInformationObjectSet1} {@.field2} ), | |
52744 | field2 MY-CLASS-1.&fixedTypeValueField ({MyInformationObjectSet1}) | |
52745 | } | |
52746 | ||
52747 | ||
52748 | END | |
52749 | ||
52750 | <STATIC> | |
52751 | ||
52752 | import from TempA all; | |
52753 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
52754 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
52755 | ||
52756 | const BERPDU myValue := { field1 := {aSN1_Type3 := {f1 := 8}},field2 := 999 }; | |
52757 | ||
52758 | ||
52759 | <TTCN_TC:EXEC> | |
52760 | ||
52761 | if ((enc_DER_PDU(myValue) == '30093003020108020203E7'O)and(enc_CER_PDU(myValue) == '308030800201080000020203E70000'O)) {setverdict(pass);} else {setverdict(fail);} | |
52762 | ||
52763 | ||
52764 | <RESULT> | |
52765 | ||
52766 | Overall verdict: pass | |
52767 | ||
52768 | <END_TC> | |
52769 | ||
52770 | :exmp. | |
52771 | ||
52772 | .*---------------------------------------------------------------------* | |
52773 | :h3. CER + DER encoding of TYPE from Information Object | |
52774 | .*---------------------------------------------------------------------* | |
52775 | :xmp tab=0. | |
52776 | ||
52777 | <TC - CER + DER encoding of TYPE from Information Object > | |
52778 | ||
52779 | <STATIC:ASN> | |
52780 | ||
52781 | TempA | |
52782 | ||
52783 | DEFINITIONS | |
52784 | ||
52785 | ||
52786 | ::= | |
52787 | ||
52788 | BEGIN | |
52789 | ||
52790 | ||
52791 | --*************************************************************************************************** | |
52792 | --modified class taken from Gyuri ASN1 | |
52793 | --*************************************************************************************************** | |
52794 | MY-CLASS-1 ::= CLASS | |
52795 | { | |
52796 | &TypeField OPTIONAL, | |
52797 | &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL | |
52798 | ||
52799 | } | |
52800 | WITH SYNTAX | |
52801 | { | |
52802 | [TYPE FIELD &TypeField] | |
52803 | [FIXED VALUE TYPE FIELD &fixedTypeValueField] | |
52804 | } | |
52805 | ||
52806 | ASN1-Type1 ::= INTEGER | |
52807 | ||
52808 | ASN1-Type2 ::= BOOLEAN | |
52809 | ||
52810 | ASN1-Type3 ::= SEQUENCE {f1 INTEGER} | |
52811 | ||
52812 | ASN1-Type4 ::= OCTET STRING | |
52813 | ||
52814 | ||
52815 | --**************************************************************************************************** | |
52816 | -- OBJECTS using the class defined above | |
52817 | --**************************************************************************************************** | |
52818 | ||
52819 | ||
52820 | myObject-1 MY-CLASS-1 ::= | |
52821 | { | |
52822 | TYPE FIELD ASN1-Type3 | |
52823 | FIXED VALUE TYPE FIELD 999 | |
52824 | } | |
52825 | ||
52826 | ||
52827 | myObject-2 MY-CLASS-1 ::= | |
52828 | { | |
52829 | TYPE FIELD ASN1-Type2 | |
52830 | FIXED VALUE TYPE FIELD 888 | |
52831 | } | |
52832 | ||
52833 | myObject-3 MY-CLASS-1 ::= | |
52834 | { | |
52835 | TYPE FIELD ASN1-Type4 | |
52836 | FIXED VALUE TYPE FIELD 555 | |
52837 | } | |
52838 | ||
52839 | --**************************************************************************************************** | |
52840 | -- Defining Information Object sets | |
52841 | --**************************************************************************************************** | |
52842 | ||
52843 | MyInformationObjectSet1 MY-CLASS-1 ::= | |
52844 | { | |
52845 | myObject-1| | |
52846 | myObject-2, | |
52847 | ... | |
52848 | } | |
52849 | ||
52850 | MyInformationObjectSet2 MY-CLASS-1 ::= | |
52851 | { | |
52852 | MyInformationObjectSet1| | |
52853 | myObject-3, | |
52854 | ... | |
52855 | } | |
52856 | ||
52857 | ||
52858 | ||
52859 | BERPDU ::= SEQUENCE | |
52860 | ||
52861 | { | |
52862 | field1 myObject-1.&TypeField , -- type from object | |
52863 | field2 MY-CLASS-1.&fixedTypeValueField | |
52864 | } | |
52865 | ||
52866 | END | |
52867 | ||
52868 | ||
52869 | <STATIC> | |
52870 | ||
52871 | import from TempA all; | |
52872 | external function enc_DER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
52873 | external function enc_CER_PDU(in BERPDU pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_CER)" } | |
52874 | ||
52875 | const BERPDU myValue := { field1 := {f1 := 8},field2 := 999 }; | |
52876 | ||
52877 | ||
52878 | <TTCN_TC:EXEC> | |
52879 | ||
52880 | if ((enc_DER_PDU(myValue) == '30093003020108020203E7'O)and(enc_CER_PDU(myValue) == '308030800201080000020203E70000'O)) {setverdict(pass);} else {setverdict(fail);} | |
52881 | ||
52882 | ||
52883 | <RESULT> | |
52884 | ||
52885 | Overall verdict: pass | |
52886 | ||
52887 | <END_TC> | |
52888 | ||
52889 | :exmp. | |
52890 | ||
52891 | .*---------------------------------------------------------------------* | |
52892 | :h3. DECODING ,OPEN TYPE, DER, from Information Object Class | |
52893 | .*---------------------------------------------------------------------* | |
52894 | :xmp tab=0. | |
52895 | ||
52896 | <TC - DECODING ,OPEN TYPE, DER, from Information Object Class> | |
52897 | ||
52898 | <STATIC:ASN> | |
52899 | ||
52900 | ||
52901 | TempA | |
52902 | ||
52903 | DEFINITIONS ::= | |
52904 | BEGIN | |
52905 | ||
52906 | ||
52907 | --*************************************************************************************************** | |
52908 | --modified class taken from Gyuri ASN1 | |
52909 | --*************************************************************************************************** | |
52910 | MY-CLASS-1 ::= CLASS | |
52911 | { | |
52912 | &TypeField OPTIONAL, | |
52913 | &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL | |
52914 | ||
52915 | } | |
52916 | WITH SYNTAX | |
52917 | { | |
52918 | [TYPE FIELD &TypeField] | |
52919 | [FIXED VALUE TYPE FIELD &fixedTypeValueField] | |
52920 | } | |
52921 | ||
52922 | ASN1-Type1 ::= INTEGER | |
52923 | ||
52924 | ASN1-Type2 ::= BOOLEAN | |
52925 | ||
52926 | ASN1-Type3 ::= SEQUENCE {f1 INTEGER} | |
52927 | ||
52928 | ASN1-Type4 ::= OCTET STRING | |
52929 | ||
52930 | ||
52931 | --**************************************************************************************************** | |
52932 | -- OBJECTS using the class defined above | |
52933 | --**************************************************************************************************** | |
52934 | ||
52935 | ||
52936 | myObject-1 MY-CLASS-1 ::= | |
52937 | { | |
52938 | TYPE FIELD ASN1-Type3 | |
52939 | FIXED VALUE TYPE FIELD 999 | |
52940 | } | |
52941 | ||
52942 | ||
52943 | myObject-2 MY-CLASS-1 ::= | |
52944 | { | |
52945 | TYPE FIELD ASN1-Type2 | |
52946 | FIXED VALUE TYPE FIELD 888 | |
52947 | } | |
52948 | ||
52949 | myObject-3 MY-CLASS-1 ::= | |
52950 | { | |
52951 | TYPE FIELD ASN1-Type4 | |
52952 | FIXED VALUE TYPE FIELD 555 | |
52953 | } | |
52954 | ||
52955 | --**************************************************************************************************** | |
52956 | -- Defining Information Object sets | |
52957 | --**************************************************************************************************** | |
52958 | ||
52959 | MyInformationObjectSet1 MY-CLASS-1 ::= | |
52960 | { | |
52961 | myObject-1| | |
52962 | myObject-2, | |
52963 | ... | |
52964 | } | |
52965 | ||
52966 | MyInformationObjectSet2 MY-CLASS-1 ::= | |
52967 | { | |
52968 | MyInformationObjectSet1| | |
52969 | myObject-3, | |
52970 | ... | |
52971 | } | |
52972 | ||
52973 | BERPDU ::= SEQUENCE | |
52974 | ||
52975 | { | |
52976 | field1 MY-CLASS-1.&TypeField ({MyInformationObjectSet1} {@.field2} ), | |
52977 | field2 MY-CLASS-1.&fixedTypeValueField ({MyInformationObjectSet1}) | |
52978 | } | |
52979 | ||
52980 | ||
52981 | END | |
52982 | <STATIC> | |
52983 | ||
52984 | import from TempA all; | |
52985 | ||
52986 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
52987 | ||
52988 | const BERPDU myValue := { field1 := {aSN1_Type3 := {f1 := 8}}, field2 := 999}; | |
52989 | ||
52990 | ||
52991 | <TTCN_TC:EXEC> | |
52992 | ||
52993 | if (dec_BER_PDU('30093003020108020203E7'O) == myValue) | |
52994 | ||
52995 | {setverdict(pass);} else {setverdict(fail);} | |
52996 | ||
52997 | ||
52998 | <RESULT> | |
52999 | ||
53000 | Overall verdict: pass | |
53001 | ||
53002 | <END_TC> | |
53003 | ||
53004 | :exmp. | |
53005 | ||
53006 | .*---------------------------------------------------------------------* | |
53007 | :h3. DECODING ,OPEN TYPE, CER, from Information Object Class | |
53008 | .*---------------------------------------------------------------------* | |
53009 | :xmp tab=0. | |
53010 | ||
53011 | <TC - DECODING ,OPEN TYPE, CER, from Information Object Class> | |
53012 | ||
53013 | <STATIC:ASN> | |
53014 | ||
53015 | ||
53016 | TempA | |
53017 | ||
53018 | DEFINITIONS ::= | |
53019 | BEGIN | |
53020 | ||
53021 | ||
53022 | --*************************************************************************************************** | |
53023 | --modified class taken from Gyuri ASN1 | |
53024 | --*************************************************************************************************** | |
53025 | MY-CLASS-1 ::= CLASS | |
53026 | { | |
53027 | &TypeField OPTIONAL, | |
53028 | &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL | |
53029 | ||
53030 | } | |
53031 | WITH SYNTAX | |
53032 | { | |
53033 | [TYPE FIELD &TypeField] | |
53034 | [FIXED VALUE TYPE FIELD &fixedTypeValueField] | |
53035 | } | |
53036 | ||
53037 | ASN1-Type1 ::= INTEGER | |
53038 | ||
53039 | ASN1-Type2 ::= BOOLEAN | |
53040 | ||
53041 | ASN1-Type3 ::= SEQUENCE {f1 INTEGER} | |
53042 | ||
53043 | ASN1-Type4 ::= OCTET STRING | |
53044 | ||
53045 | ||
53046 | --**************************************************************************************************** | |
53047 | -- OBJECTS using the class defined above | |
53048 | --**************************************************************************************************** | |
53049 | ||
53050 | ||
53051 | myObject-1 MY-CLASS-1 ::= | |
53052 | { | |
53053 | TYPE FIELD ASN1-Type3 | |
53054 | FIXED VALUE TYPE FIELD 999 | |
53055 | } | |
53056 | ||
53057 | ||
53058 | myObject-2 MY-CLASS-1 ::= | |
53059 | { | |
53060 | TYPE FIELD ASN1-Type2 | |
53061 | FIXED VALUE TYPE FIELD 888 | |
53062 | } | |
53063 | ||
53064 | myObject-3 MY-CLASS-1 ::= | |
53065 | { | |
53066 | TYPE FIELD ASN1-Type4 | |
53067 | FIXED VALUE TYPE FIELD 555 | |
53068 | } | |
53069 | ||
53070 | --**************************************************************************************************** | |
53071 | -- Defining Information Object sets | |
53072 | --**************************************************************************************************** | |
53073 | ||
53074 | MyInformationObjectSet1 MY-CLASS-1 ::= | |
53075 | { | |
53076 | myObject-1| | |
53077 | myObject-2, | |
53078 | ... | |
53079 | } | |
53080 | ||
53081 | MyInformationObjectSet2 MY-CLASS-1 ::= | |
53082 | { | |
53083 | MyInformationObjectSet1| | |
53084 | myObject-3, | |
53085 | ... | |
53086 | } | |
53087 | ||
53088 | BERPDU ::= SEQUENCE | |
53089 | ||
53090 | { | |
53091 | field1 MY-CLASS-1.&TypeField ({MyInformationObjectSet1} {@.field2} ), | |
53092 | field2 MY-CLASS-1.&fixedTypeValueField ({MyInformationObjectSet1}) | |
53093 | } | |
53094 | ||
53095 | ||
53096 | END | |
53097 | <STATIC> | |
53098 | ||
53099 | import from TempA all; | |
53100 | ||
53101 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
53102 | ||
53103 | const BERPDU myValue := { field1 := {aSN1_Type3 := {f1 := 8}}, field2 := 999}; | |
53104 | ||
53105 | ||
53106 | <TTCN_TC:EXEC> | |
53107 | ||
53108 | if (dec_BER_PDU('308030800201080000020203E70000'O) == myValue) | |
53109 | ||
53110 | {setverdict(pass);} else {setverdict(fail);} | |
53111 | ||
53112 | ||
53113 | <RESULT> | |
53114 | ||
53115 | Overall verdict: pass | |
53116 | ||
53117 | <END_TC> | |
53118 | ||
53119 | :exmp. | |
53120 | ||
53121 | .*---------------------------------------------------------------------* | |
53122 | :h3. DECODING , TYPE from Information Object Class, DER | |
53123 | .*---------------------------------------------------------------------* | |
53124 | :xmp tab=0. | |
53125 | ||
53126 | <TC - DECODING , TYPE from Information Object Class, DER> | |
53127 | ||
53128 | <STATIC:ASN> | |
53129 | ||
53130 | ||
53131 | TempA | |
53132 | ||
53133 | DEFINITIONS | |
53134 | ||
53135 | ||
53136 | ::= | |
53137 | ||
53138 | BEGIN | |
53139 | ||
53140 | ||
53141 | --*************************************************************************************************** | |
53142 | --modified class taken from Gyuri ASN1 | |
53143 | --*************************************************************************************************** | |
53144 | MY-CLASS-1 ::= CLASS | |
53145 | { | |
53146 | &TypeField OPTIONAL, | |
53147 | &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL | |
53148 | ||
53149 | } | |
53150 | WITH SYNTAX | |
53151 | { | |
53152 | [TYPE FIELD &TypeField] | |
53153 | [FIXED VALUE TYPE FIELD &fixedTypeValueField] | |
53154 | } | |
53155 | ||
53156 | ASN1-Type1 ::= INTEGER | |
53157 | ||
53158 | ASN1-Type2 ::= BOOLEAN | |
53159 | ||
53160 | ASN1-Type3 ::= SEQUENCE {f1 INTEGER} | |
53161 | ||
53162 | ASN1-Type4 ::= OCTET STRING | |
53163 | ||
53164 | ||
53165 | --**************************************************************************************************** | |
53166 | -- OBJECTS using the class defined above | |
53167 | --**************************************************************************************************** | |
53168 | ||
53169 | ||
53170 | myObject-1 MY-CLASS-1 ::= | |
53171 | { | |
53172 | TYPE FIELD ASN1-Type3 | |
53173 | FIXED VALUE TYPE FIELD 999 | |
53174 | } | |
53175 | ||
53176 | ||
53177 | myObject-2 MY-CLASS-1 ::= | |
53178 | { | |
53179 | TYPE FIELD ASN1-Type2 | |
53180 | FIXED VALUE TYPE FIELD 888 | |
53181 | } | |
53182 | ||
53183 | myObject-3 MY-CLASS-1 ::= | |
53184 | { | |
53185 | TYPE FIELD ASN1-Type4 | |
53186 | FIXED VALUE TYPE FIELD 555 | |
53187 | } | |
53188 | ||
53189 | --**************************************************************************************************** | |
53190 | -- Defining Information Object sets | |
53191 | --**************************************************************************************************** | |
53192 | ||
53193 | MyInformationObjectSet1 MY-CLASS-1 ::= | |
53194 | { | |
53195 | myObject-1| | |
53196 | myObject-2, | |
53197 | ... | |
53198 | } | |
53199 | ||
53200 | MyInformationObjectSet2 MY-CLASS-1 ::= | |
53201 | { | |
53202 | MyInformationObjectSet1| | |
53203 | myObject-3, | |
53204 | ... | |
53205 | } | |
53206 | ||
53207 | ||
53208 | ||
53209 | BERPDU ::= SEQUENCE | |
53210 | ||
53211 | { | |
53212 | field1 myObject-1.&TypeField , -- type from object | |
53213 | field2 MY-CLASS-1.&fixedTypeValueField | |
53214 | } | |
53215 | ||
53216 | END | |
53217 | ||
53218 | <STATIC> | |
53219 | ||
53220 | import from TempA all; | |
53221 | ||
53222 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
53223 | ||
53224 | const BERPDU myValue := { field1 := {f1 := 8}, field2 := 999}; | |
53225 | ||
53226 | ||
53227 | <TTCN_TC:EXEC> | |
53228 | ||
53229 | if (dec_BER_PDU('30093003020108020203E7'O) == myValue) | |
53230 | ||
53231 | {setverdict(pass);} else {setverdict(fail);} | |
53232 | ||
53233 | ||
53234 | <RESULT> | |
53235 | ||
53236 | Overall verdict: pass | |
53237 | ||
53238 | <END_TC> | |
53239 | ||
53240 | :exmp. | |
53241 | ||
53242 | .*---------------------------------------------------------------------* | |
53243 | :h3. DECODING , TYPE from Information Object Class, CER | |
53244 | .*---------------------------------------------------------------------* | |
53245 | :xmp tab=0. | |
53246 | ||
53247 | <TC - DECODING , TYPE from Information Object Class, CER> | |
53248 | ||
53249 | <STATIC:ASN> | |
53250 | ||
53251 | ||
53252 | TempA | |
53253 | ||
53254 | DEFINITIONS | |
53255 | ||
53256 | ||
53257 | ::= | |
53258 | ||
53259 | BEGIN | |
53260 | ||
53261 | ||
53262 | --*************************************************************************************************** | |
53263 | --modified class taken from Gyuri ASN1 | |
53264 | --*************************************************************************************************** | |
53265 | MY-CLASS-1 ::= CLASS | |
53266 | { | |
53267 | &TypeField OPTIONAL, | |
53268 | &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL | |
53269 | ||
53270 | } | |
53271 | WITH SYNTAX | |
53272 | { | |
53273 | [TYPE FIELD &TypeField] | |
53274 | [FIXED VALUE TYPE FIELD &fixedTypeValueField] | |
53275 | } | |
53276 | ||
53277 | ASN1-Type1 ::= INTEGER | |
53278 | ||
53279 | ASN1-Type2 ::= BOOLEAN | |
53280 | ||
53281 | ASN1-Type3 ::= SEQUENCE {f1 INTEGER} | |
53282 | ||
53283 | ASN1-Type4 ::= OCTET STRING | |
53284 | ||
53285 | ||
53286 | --**************************************************************************************************** | |
53287 | -- OBJECTS using the class defined above | |
53288 | --**************************************************************************************************** | |
53289 | ||
53290 | ||
53291 | myObject-1 MY-CLASS-1 ::= | |
53292 | { | |
53293 | TYPE FIELD ASN1-Type3 | |
53294 | FIXED VALUE TYPE FIELD 999 | |
53295 | } | |
53296 | ||
53297 | ||
53298 | myObject-2 MY-CLASS-1 ::= | |
53299 | { | |
53300 | TYPE FIELD ASN1-Type2 | |
53301 | FIXED VALUE TYPE FIELD 888 | |
53302 | } | |
53303 | ||
53304 | myObject-3 MY-CLASS-1 ::= | |
53305 | { | |
53306 | TYPE FIELD ASN1-Type4 | |
53307 | FIXED VALUE TYPE FIELD 555 | |
53308 | } | |
53309 | ||
53310 | --**************************************************************************************************** | |
53311 | -- Defining Information Object sets | |
53312 | --**************************************************************************************************** | |
53313 | ||
53314 | MyInformationObjectSet1 MY-CLASS-1 ::= | |
53315 | { | |
53316 | myObject-1| | |
53317 | myObject-2, | |
53318 | ... | |
53319 | } | |
53320 | ||
53321 | MyInformationObjectSet2 MY-CLASS-1 ::= | |
53322 | { | |
53323 | MyInformationObjectSet1| | |
53324 | myObject-3, | |
53325 | ... | |
53326 | } | |
53327 | ||
53328 | ||
53329 | ||
53330 | BERPDU ::= SEQUENCE | |
53331 | ||
53332 | { | |
53333 | field1 myObject-1.&TypeField , -- type from object | |
53334 | field2 MY-CLASS-1.&fixedTypeValueField | |
53335 | } | |
53336 | ||
53337 | END | |
53338 | ||
53339 | <STATIC> | |
53340 | ||
53341 | import from TempA all; | |
53342 | ||
53343 | external function dec_BER_PDU(in octetstring stream) return BERPDU with { extension "prototype(convert) decode(BER)" } | |
53344 | ||
53345 | const BERPDU myValue := { field1 := {f1 := 8}, field2 := 999}; | |
53346 | ||
53347 | ||
53348 | <TTCN_TC:EXEC> | |
53349 | ||
53350 | if (dec_BER_PDU('308030800201080000020203E70000'O) == myValue) | |
53351 | ||
53352 | {setverdict(pass);} else {setverdict(fail);} | |
53353 | ||
53354 | ||
53355 | <RESULT> | |
53356 | ||
53357 | Overall verdict: pass | |
53358 | ||
53359 | <END_TC> | |
53360 | ||
53361 | :exmp. | |
53362 | ||
53363 | ||
53364 | .*---------------------------------------------------------------------* | |
53365 | :h2.Testing Enc/Dec functions of implicit message encoding | |
53366 | .*---------------------------------------------------------------------* | |
53367 | .*---------------------------------------------------------------------* | |
53368 | :h3. Fast enc/dec function | |
53369 | .*---------------------------------------------------------------------* | |
53370 | :xmp tab=0. | |
53371 | ||
53372 | <TC- Implicit message encoding: prototype fast> | |
53373 | ||
53374 | <STATIC:ASN> | |
53375 | ||
53376 | TempA | |
53377 | DEFINITIONS | |
53378 | AUTOMATIC TAGS | |
53379 | ::= | |
53380 | BEGIN | |
53381 | BERPDU ::= SEQUENCE | |
53382 | { | |
53383 | a OCTET STRING, | |
53384 | b BOOLEAN, | |
53385 | ..., | |
53386 | d BIT STRING, | |
53387 | ..., | |
53388 | c INTEGER OPTIONAL | |
53389 | } | |
53390 | END | |
53391 | ||
53392 | <STATIC> | |
53393 | ||
53394 | import from TempA all; | |
53395 | external function enc_DER_PDU(in BERPDU pdu, out octetstring os) with { extension "prototype(fast) encode(BER:BER_ENCODE_DER)" } | |
53396 | external function enc_CER_PDU(in BERPDU pdu, out octetstring os) with { extension "prototype(fast) encode(BER:BER_ENCODE_CER)" } | |
53397 | external function dec_BER_PDU(in octetstring os, out BERPDU pdu) | |
53398 | with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53399 | ||
53400 | const BERPDU myValue := { | |
53401 | a := 'FF'O, | |
53402 | b := true, | |
53403 | d := '1'B, | |
53404 | c := 4 | |
53405 | } | |
53406 | <TTCN_TC:EXEC> | |
53407 | ||
53408 | var octetstring der_encoded, cer_encoded; | |
53409 | var BERPDU der_decoded, cer_decoded; | |
53410 | ||
53411 | enc_DER_PDU(myValue, der_encoded); | |
53412 | enc_CER_PDU(myValue, cer_encoded); | |
53413 | ||
53414 | if ((der_encoded == '300D8001FF8101FF83020780820104'O) and | |
53415 | (cer_encoded == '30808001FF8101FF830207808201040000'O)) | |
53416 | {setverdict(pass);} else {setverdict(fail);} | |
53417 | ||
53418 | dec_BER_PDU(der_encoded, der_decoded); | |
53419 | if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);} | |
53420 | dec_BER_PDU(cer_encoded, cer_decoded); | |
53421 | if (cer_decoded==myValue) {setverdict(pass);} else {setverdict(fail);} | |
53422 | ||
53423 | <RESULT> | |
53424 | ||
53425 | Overall verdict: pass | |
53426 | ||
53427 | <END_TC> | |
53428 | ||
53429 | :exmp. | |
53430 | ||
53431 | .*---------------------------------------------------------------------* | |
53432 | :h3. Backtrack decode function | |
53433 | .*---------------------------------------------------------------------* | |
53434 | :xmp tab=0. | |
53435 | ||
53436 | <TC- Implicit message encoding: prototype backtrack> | |
53437 | ||
53438 | <STATIC:ASN> | |
53439 | ||
53440 | TempA | |
53441 | DEFINITIONS | |
53442 | AUTOMATIC TAGS | |
53443 | ::= | |
53444 | BEGIN | |
53445 | STRPDU ::= PrintableString | |
53446 | USTRPDU ::= GeneralString | |
53447 | SEQPDU ::= SEQUENCE { | |
53448 | f1 INTEGER, | |
53449 | f2 OCTET STRING, | |
53450 | f3 BOOLEAN | |
53451 | } | |
53452 | END | |
53453 | ||
53454 | <STATIC> | |
53455 | ||
53456 | import from TempA all; | |
53457 | ||
53458 | external function encode_str(in STRPDU pdu) return octetstring | |
53459 | with { extension "prototype(convert) encode(BER)" } | |
53460 | external function encode_ustr(in USTRPDU updu) return octetstring | |
53461 | with { extension "prototype(convert) encode(BER)" } | |
53462 | external function encode_seq(in SEQPDU pdu) return octetstring | |
53463 | with { extension "prototype(convert) encode(BER)" } | |
53464 | external function decode_str(in octetstring os, out STRPDU pdu) return integer | |
53465 | with { extension "prototype(backtrack) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53466 | external function decode_ustr(in octetstring os, out USTRPDU pdu) return integer | |
53467 | with { extension "prototype(backtrack) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53468 | external function decode_seq(in octetstring os, out SEQPDU pdu) return integer | |
53469 | with { extension "prototype(backtrack) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53470 | ||
53471 | <TTCN_TC:EXEC> | |
53472 | ||
53473 | var STRPDU str := "haha"; | |
53474 | var USTRPDU ustr := "uu"; | |
53475 | var SEQPDU seq := { 123, 'ABCDEF'O, true } | |
53476 | var STRPDU decoded_str; | |
53477 | var USTRPDU decoded_ustr; | |
53478 | var SEQPDU decoded_seq; | |
53479 | var integer ret_val; | |
53480 | ||
53481 | ret_val := decode_str(encode_str(str), decoded_str); | |
53482 | if (ret_val==0 and decoded_str==str) {setverdict(pass);} else {setverdict(fail);} | |
53483 | ret_val := decode_ustr(encode_ustr(ustr), decoded_ustr); | |
53484 | if (ret_val==0 and decoded_ustr==ustr) {setverdict(pass);} else {setverdict(fail);} | |
53485 | ret_val := decode_seq(encode_seq(seq), decoded_seq); | |
53486 | if (ret_val==0 and decoded_seq==seq) {setverdict(pass);} else {setverdict(fail);} | |
53487 | ||
53488 | ret_val := decode_str(''O, decoded_str); | |
53489 | if (ret_val==1) {setverdict(pass);} else {setverdict(fail);} | |
53490 | ret_val := decode_ustr(''O, decoded_ustr); | |
53491 | if (ret_val==1) {setverdict(pass);} else {setverdict(fail);} | |
53492 | ret_val := decode_seq(''O, decoded_seq); | |
53493 | if (ret_val==1) {setverdict(pass);} else {setverdict(fail);} | |
53494 | ||
53495 | ret_val := decode_str('12'O, decoded_str); | |
53496 | if (ret_val==1) {setverdict(pass);} else {setverdict(fail);} | |
53497 | ret_val := decode_ustr('12'O, decoded_ustr); | |
53498 | if (ret_val==1) {setverdict(pass);} else {setverdict(fail);} | |
53499 | ret_val := decode_seq('12'O, decoded_seq); | |
53500 | if (ret_val==1) {setverdict(pass);} else {setverdict(fail);} | |
53501 | ||
53502 | ret_val := decode_str('1234'O, decoded_str); | |
53503 | if (ret_val==1) {setverdict(pass);} else {setverdict(fail);} | |
53504 | ret_val := decode_ustr('1234'O, decoded_ustr); | |
53505 | if (ret_val==1) {setverdict(pass);} else {setverdict(fail);} | |
53506 | ret_val := decode_seq('1234'O, decoded_seq); | |
53507 | if (ret_val==1) {setverdict(pass);} else {setverdict(fail);} | |
53508 | ||
53509 | <RESULT> | |
53510 | ||
53511 | Overall verdict: pass | |
53512 | ||
53513 | <END_TC> | |
53514 | ||
53515 | :exmp. | |
53516 | ||
53517 | .*---------------------------------------------------------------------* | |
53518 | :h3. Sliding decode function | |
53519 | .*---------------------------------------------------------------------* | |
53520 | :xmp tab=0. | |
53521 | ||
53522 | <TC- Implicit message encoding: prototype sliding> | |
53523 | ||
53524 | <STATIC:ASN> | |
53525 | ||
53526 | TempA | |
53527 | DEFINITIONS | |
53528 | AUTOMATIC TAGS | |
53529 | ::= | |
53530 | BEGIN | |
53531 | PDU ::= SEQUENCE { | |
53532 | f1 INTEGER, | |
53533 | f2 OCTET STRING, | |
53534 | f3 BOOLEAN | |
53535 | } | |
53536 | END | |
53537 | ||
53538 | <STATIC> | |
53539 | ||
53540 | import from TempA all; | |
53541 | ||
53542 | external function encode_PDU(in PDU pdu) return octetstring | |
53543 | with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
53544 | external function decode_PDU(inout octetstring os, out PDU pdu) return integer | |
53545 | with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53546 | ||
53547 | <TTCN_TC:EXEC> | |
53548 | ||
53549 | var PDU pdu := { 123, 'ABCDEF'O, true } | |
53550 | var octetstring encoded_pdu; | |
53551 | var PDU decoded_pdu; | |
53552 | var integer ret_val; | |
53553 | ||
53554 | encoded_pdu := encode_PDU(pdu); | |
53555 | ret_val := decode_PDU(encoded_pdu, decoded_pdu); | |
53556 | if (ret_val==0 and decoded_pdu==pdu) {setverdict(pass);} else {setverdict(fail);} | |
53557 | ||
53558 | encoded_pdu := '800100'O; | |
53559 | ret_val := decode_PDU(encoded_pdu, decoded_pdu); | |
53560 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53561 | ||
53562 | encoded_pdu := substr(encode_PDU(pdu), 0, 4); | |
53563 | ret_val := decode_PDU(encoded_pdu, decoded_pdu); | |
53564 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53565 | ||
53566 | <RESULT> | |
53567 | ||
53568 | Overall verdict: pass | |
53569 | ||
53570 | <END_TC> | |
53571 | ||
53572 | :exmp. | |
53573 | ||
53574 | .*---------------------------------------------------------------------* | |
53575 | :h3. Sliding decoding, octetstring length 0,1,2 -> incomplete TLV | |
53576 | .*---------------------------------------------------------------------* | |
53577 | :xmp tab=0. | |
53578 | ||
53579 | <TC- Implicit message encoding: incomplete TLV> | |
53580 | ||
53581 | <STATIC:ASN> | |
53582 | ||
53583 | TempA | |
53584 | DEFINITIONS | |
53585 | AUTOMATIC TAGS | |
53586 | ::= | |
53587 | BEGIN | |
53588 | PDU0 ::= NULL | |
53589 | PDU1 ::= BOOLEAN | |
53590 | PDU2 ::= INTEGER | |
53591 | PDU3 ::= ENUMERATED { e0 (0), e1 (1) } | |
53592 | PDU4 ::= REAL | |
53593 | PDU5 ::= BIT STRING | |
53594 | PDU6 ::= OCTET STRING | |
53595 | PDU7 ::= PrintableString | |
53596 | PDU8 ::= GeneralString | |
53597 | PDU9 ::= CHOICE { i INTEGER, b BOOLEAN } | |
53598 | PDU10 ::= SEQUENCE { i INTEGER, b BOOLEAN } | |
53599 | PDU11 ::= SEQUENCE OF INTEGER | |
53600 | PDU12 ::= OBJECT IDENTIFIER | |
53601 | END | |
53602 | ||
53603 | <STATIC> | |
53604 | ||
53605 | import from TempA all; | |
53606 | ||
53607 | external function encode_PDU0(in PDU0 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
53608 | external function decode_PDU0(inout octetstring os, out PDU0 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53609 | ||
53610 | external function encode_PDU1(in PDU1 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
53611 | external function decode_PDU1(inout octetstring os, out PDU1 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53612 | ||
53613 | external function encode_PDU2(in PDU2 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
53614 | external function decode_PDU2(inout octetstring os, out PDU2 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53615 | ||
53616 | external function encode_PDU3(in PDU3 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
53617 | external function decode_PDU3(inout octetstring os, out PDU3 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53618 | ||
53619 | external function encode_PDU4(in PDU4 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
53620 | external function decode_PDU4(inout octetstring os, out PDU4 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53621 | ||
53622 | external function encode_PDU5(in PDU5 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
53623 | external function decode_PDU5(inout octetstring os, out PDU5 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53624 | ||
53625 | external function encode_PDU6(in PDU6 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
53626 | external function decode_PDU6(inout octetstring os, out PDU6 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53627 | ||
53628 | external function encode_PDU7(in PDU7 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
53629 | external function decode_PDU7(inout octetstring os, out PDU7 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53630 | ||
53631 | external function encode_PDU8(in PDU8 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
53632 | external function decode_PDU8(inout octetstring os, out PDU8 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53633 | ||
53634 | external function encode_PDU9(in PDU9 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
53635 | external function decode_PDU9(inout octetstring os, out PDU9 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53636 | ||
53637 | external function encode_PDU10(in PDU10 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
53638 | external function decode_PDU10(inout octetstring os, out PDU10 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53639 | ||
53640 | external function encode_PDU11(in PDU11 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
53641 | external function decode_PDU11(inout octetstring os, out PDU11 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53642 | ||
53643 | external function encode_PDU12(in PDU12 pdu) return octetstring with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" } | |
53644 | external function decode_PDU12(inout octetstring os, out PDU12 pdu) return integer with { extension "prototype(sliding) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
53645 | ||
53646 | <TTCN_TC:EXEC> | |
53647 | ||
53648 | var octetstring encoded_pdu; | |
53649 | var integer ret_val; | |
53650 | ||
53651 | var PDU0 pdu0 := NULL; | |
53652 | var PDU0 decoded_pdu0; | |
53653 | encoded_pdu := substr(encode_PDU0(pdu0), 0, 0); | |
53654 | ret_val := decode_PDU0(encoded_pdu, decoded_pdu0); | |
53655 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53656 | encoded_pdu := substr(encode_PDU0(pdu0), 0, 1); | |
53657 | ret_val := decode_PDU0(encoded_pdu, decoded_pdu0); | |
53658 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53659 | ||
53660 | var PDU1 pdu1 := true; | |
53661 | var PDU1 decoded_pdu1; | |
53662 | encoded_pdu := substr(encode_PDU1(pdu1), 0, 0); | |
53663 | ret_val := decode_PDU1(encoded_pdu, decoded_pdu1); | |
53664 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53665 | encoded_pdu := substr(encode_PDU1(pdu1), 0, 1); | |
53666 | ret_val := decode_PDU1(encoded_pdu, decoded_pdu1); | |
53667 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53668 | encoded_pdu := substr(encode_PDU1(pdu1), 0, 2); | |
53669 | ret_val := decode_PDU1(encoded_pdu, decoded_pdu1); | |
53670 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53671 | ||
53672 | var PDU2 pdu2 := 123; | |
53673 | var PDU2 decoded_pdu2; | |
53674 | encoded_pdu := substr(encode_PDU2(pdu2), 0, 0); | |
53675 | ret_val := decode_PDU2(encoded_pdu, decoded_pdu2); | |
53676 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53677 | encoded_pdu := substr(encode_PDU2(pdu2), 0, 1); | |
53678 | ret_val := decode_PDU2(encoded_pdu, decoded_pdu2); | |
53679 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53680 | encoded_pdu := substr(encode_PDU2(pdu2), 0, 2); | |
53681 | ret_val := decode_PDU2(encoded_pdu, decoded_pdu2); | |
53682 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53683 | ||
53684 | var PDU3 pdu3 := e1; | |
53685 | var PDU3 decoded_pdu3; | |
53686 | encoded_pdu := substr(encode_PDU3(pdu3), 0, 0); | |
53687 | ret_val := decode_PDU3(encoded_pdu, decoded_pdu3); | |
53688 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53689 | encoded_pdu := substr(encode_PDU3(pdu3), 0, 1); | |
53690 | ret_val := decode_PDU3(encoded_pdu, decoded_pdu3); | |
53691 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53692 | encoded_pdu := substr(encode_PDU3(pdu3), 0, 2); | |
53693 | ret_val := decode_PDU3(encoded_pdu, decoded_pdu3); | |
53694 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53695 | ||
53696 | var PDU4 pdu4 := 1.23; | |
53697 | var PDU4 decoded_pdu4; | |
53698 | encoded_pdu := substr(encode_PDU4(pdu4), 0, 0); | |
53699 | ret_val := decode_PDU4(encoded_pdu, decoded_pdu4); | |
53700 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53701 | encoded_pdu := substr(encode_PDU4(pdu4), 0, 1); | |
53702 | ret_val := decode_PDU4(encoded_pdu, decoded_pdu4); | |
53703 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53704 | encoded_pdu := substr(encode_PDU4(pdu4), 0, 2); | |
53705 | ret_val := decode_PDU4(encoded_pdu, decoded_pdu4); | |
53706 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53707 | ||
53708 | var PDU5 pdu5 := '101010'B; | |
53709 | var PDU5 decoded_pdu5; | |
53710 | encoded_pdu := substr(encode_PDU5(pdu5), 0, 0); | |
53711 | ret_val := decode_PDU5(encoded_pdu, decoded_pdu5); | |
53712 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53713 | encoded_pdu := substr(encode_PDU5(pdu5), 0, 1); | |
53714 | ret_val := decode_PDU5(encoded_pdu, decoded_pdu5); | |
53715 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53716 | encoded_pdu := substr(encode_PDU5(pdu5), 0, 2); | |
53717 | ret_val := decode_PDU5(encoded_pdu, decoded_pdu5); | |
53718 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53719 | ||
53720 | var PDU6 pdu6 := 'ABCDEF12'O; | |
53721 | var PDU6 decoded_pdu6; | |
53722 | encoded_pdu := substr(encode_PDU6(pdu6), 0, 0); | |
53723 | ret_val := decode_PDU6(encoded_pdu, decoded_pdu6); | |
53724 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53725 | encoded_pdu := substr(encode_PDU6(pdu6), 0, 1); | |
53726 | ret_val := decode_PDU6(encoded_pdu, decoded_pdu6); | |
53727 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53728 | encoded_pdu := substr(encode_PDU6(pdu6), 0, 2); | |
53729 | ret_val := decode_PDU6(encoded_pdu, decoded_pdu6); | |
53730 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53731 | ||
53732 | var PDU7 pdu7 := "haha"; | |
53733 | var PDU7 decoded_pdu7; | |
53734 | encoded_pdu := substr(encode_PDU7(pdu7), 0, 0); | |
53735 | ret_val := decode_PDU7(encoded_pdu, decoded_pdu7); | |
53736 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53737 | encoded_pdu := substr(encode_PDU7(pdu7), 0, 1); | |
53738 | ret_val := decode_PDU7(encoded_pdu, decoded_pdu7); | |
53739 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53740 | encoded_pdu := substr(encode_PDU7(pdu7), 0, 2); | |
53741 | ret_val := decode_PDU7(encoded_pdu, decoded_pdu7); | |
53742 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53743 | ||
53744 | var PDU8 pdu8 := "huhu"; | |
53745 | var PDU8 decoded_pdu8; | |
53746 | encoded_pdu := substr(encode_PDU8(pdu8), 0, 0); | |
53747 | ret_val := decode_PDU8(encoded_pdu, decoded_pdu8); | |
53748 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53749 | encoded_pdu := substr(encode_PDU8(pdu8), 0, 1); | |
53750 | ret_val := decode_PDU8(encoded_pdu, decoded_pdu8); | |
53751 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53752 | encoded_pdu := substr(encode_PDU8(pdu8), 0, 2); | |
53753 | ret_val := decode_PDU8(encoded_pdu, decoded_pdu8); | |
53754 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53755 | ||
53756 | var PDU9 pdu9 := { b := true } | |
53757 | var PDU9 decoded_pdu9; | |
53758 | encoded_pdu := substr(encode_PDU9(pdu9), 0, 0); | |
53759 | ret_val := decode_PDU9(encoded_pdu, decoded_pdu9); | |
53760 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53761 | encoded_pdu := substr(encode_PDU9(pdu9), 0, 1); | |
53762 | ret_val := decode_PDU9(encoded_pdu, decoded_pdu9); | |
53763 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53764 | encoded_pdu := substr(encode_PDU9(pdu9), 0, 2); | |
53765 | ret_val := decode_PDU9(encoded_pdu, decoded_pdu9); | |
53766 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53767 | ||
53768 | var PDU10 pdu10 := { 123 , true } | |
53769 | var PDU10 decoded_pdu10; | |
53770 | encoded_pdu := substr(encode_PDU10(pdu10), 0, 0); | |
53771 | ret_val := decode_PDU10(encoded_pdu, decoded_pdu10); | |
53772 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53773 | encoded_pdu := substr(encode_PDU10(pdu10), 0, 1); | |
53774 | ret_val := decode_PDU10(encoded_pdu, decoded_pdu10); | |
53775 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53776 | encoded_pdu := substr(encode_PDU10(pdu10), 0, 2); | |
53777 | ret_val := decode_PDU10(encoded_pdu, decoded_pdu10); | |
53778 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53779 | ||
53780 | var PDU11 pdu11 := { 1, 2, 3 } | |
53781 | var PDU11 decoded_pdu11; | |
53782 | encoded_pdu := substr(encode_PDU11(pdu11), 0, 0); | |
53783 | ret_val := decode_PDU11(encoded_pdu, decoded_pdu11); | |
53784 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53785 | encoded_pdu := substr(encode_PDU11(pdu11), 0, 1); | |
53786 | ret_val := decode_PDU11(encoded_pdu, decoded_pdu11); | |
53787 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53788 | encoded_pdu := substr(encode_PDU11(pdu11), 0, 2); | |
53789 | ret_val := decode_PDU11(encoded_pdu, decoded_pdu11); | |
53790 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53791 | ||
53792 | var PDU12 pdu12 := objid { itu_t(0) 4 } | |
53793 | var PDU12 decoded_pdu12; | |
53794 | encoded_pdu := substr(encode_PDU12(pdu12), 0, 0); | |
53795 | ret_val := decode_PDU12(encoded_pdu, decoded_pdu12); | |
53796 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53797 | encoded_pdu := substr(encode_PDU12(pdu12), 0, 1); | |
53798 | ret_val := decode_PDU12(encoded_pdu, decoded_pdu12); | |
53799 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53800 | encoded_pdu := substr(encode_PDU12(pdu12), 0, 2); | |
53801 | ret_val := decode_PDU12(encoded_pdu, decoded_pdu12); | |
53802 | if (ret_val==2) {setverdict(pass);} else {setverdict(fail);} | |
53803 | ||
53804 | <RESULT> | |
53805 | ||
53806 | Overall verdict: pass | |
53807 | ||
53808 | <END_TC> | |
53809 | ||
53810 | :exmp. | |
53811 | ||
53812 | .*---------------------------------------------------------------------* | |
53813 | :h2. Encoding/decoding of big integers | |
53814 | .*---------------------------------------------------------------------* | |
53815 | .*---------------------------------------------------------------------* | |
53816 | :h3. Encoding/decoding of big integers | |
53817 | .*---------------------------------------------------------------------* | |
53818 | :xmp tab=0. | |
53819 | ||
53820 | <TC - Encoding/decoding of big integers> | |
53821 | ||
53822 | <STATIC:ASN> | |
53823 | ||
53824 | TempA DEFINITIONS AUTOMATIC TAGS ::= | |
53825 | BEGIN | |
53826 | ||
53827 | BERPDU ::= INTEGER | |
53828 | bi1 BERPDU ::= 5 | |
53829 | bi2 BERPDU ::= 0 | |
53830 | bi3 BERPDU ::= 127 | |
53831 | bi4 BERPDU ::= -128 | |
53832 | bi5 BERPDU ::= -5 | |
53833 | bi-6 BERPDU ::= 128 | |
53834 | bi7 BERPDU ::= -129 | |
53835 | ||
53836 | BERPDU2 ::= REAL | |
53837 | --b BERPDU2 ::= 12345678900 | |
53838 | ||
53839 | Rec-ber ::= SEQUENCE { | |
53840 | int1 Number, | |
53841 | int2 Number | |
53842 | } | |
53843 | Rec-ber-literal ::= SEQUENCE { | |
53844 | int1 NumberLit, | |
53845 | int2 NumberLit | |
53846 | } | |
53847 | Number ::= INTEGER | |
53848 | NumberLit ::= NumericString (SIZE (100)) | |
53849 | myNumber Number ::= 12345678910111213141516 | |
53850 | ||
53851 | END | |
53852 | ||
53853 | <STATIC> | |
53854 | ||
53855 | import from TempA language "ASN.1:1997" all | |
53856 | ||
53857 | external function enc_ber1(in Rec_ber r) return octetstring | |
53858 | with { extension "encode(BER:BER_ENCODE_DER) prototype(convert) errorbehavior(ALL:WARNING)" } | |
53859 | external function dec_ber1(in octetstring r) return Rec_ber | |
53860 | with { extension "decode(BER:BER_ACCEPT_ALL) prototype(convert) errorbehavior(ALL:WARNING)" } | |
53861 | external function enc_ber2(in integer r) return octetstring | |
53862 | with { extension "encode(BER:BER_ENCODE_DER) prototype(convert) errorbehavior(ALL:WARNING)" } | |
53863 | // Attributes are not checked in the compiler. | |
53864 | external function dec_ber2(in octetstring r) return integer | |
53865 | with { extension "decode(BER:BER_ENCODE_DER) prototype(convert) errorbehavior(ALL:WARNING)" } | |
53866 | external function dec_ber3(inout octetstring r, out Rec_ber s) return integer | |
53867 | with { extension "decode(BER:BER_ACCEPT_ALL) prototype(sliding) errorbehavior(ALL:WARNING)" } | |
53868 | ||
53869 | type component comp_ber { } | |
53870 | ||
53871 | <TTCN_TC:EXEC> | |
53872 | ||
53873 | const integer a := 2147483647 | |
53874 | const integer b := 2147483648 | |
53875 | const integer c := 2147483649 | |
53876 | const integer d := 128 | |
53877 | const integer e := myNumber | |
53878 | const integer f := 12147483648 | |
53879 | var Rec_ber myrec1 := {int1 := a, int2 := b} | |
53880 | var Rec_ber myrec2 := {int1 := c, int2 := d} | |
53881 | var Rec_ber myrec3 := {int1 := 1048576, int2 := 321768} | |
53882 | var Rec_ber myrec4 := {65536, 131072} | |
53883 | var Rec_ber myrec5 := {4294967296, 8388608} | |
53884 | var Rec_ber myrec6 := {12345678910111213141516, 11111111111111111111} | |
53885 | var Rec_ber myrec7 := {8589934592, 1099511627776} | |
53886 | var Rec_ber myrec8 := {int1 := a, int2 := b} | |
53887 | var Rec_ber myrec9 := {int1 := 12345678910111213141516, int2 := -1234} | |
53888 | var Rec_ber myrec10 := {int1 := -12345678910111213141516, int2 := -1234} | |
53889 | var Rec_ber myrec11 := {2147483648, -2147483648} | |
53890 | var Rec_ber myrec12 := {-2147483647, 2147483647} | |
53891 | var Rec_ber myrec13 := {2147483649, -2147483649} | |
53892 | var Rec_ber myrec14 := {-4294967296, 4294967296} | |
53893 | var Rec_ber myrec15 := {4294967295, -4294967295} | |
53894 | var Rec_ber myrec16 := {-4294967297, 4294967297} | |
53895 | var Rec_ber pdu1 := {12345678910111213141516, -2147483648} | |
53896 | var Rec_ber pdu2 := {123, 456} | |
53897 | var octetstring encoded_pdu | |
53898 | var Rec_ber decoded_pdu | |
53899 | var integer ret_val | |
53900 | encoded_pdu := enc_ber1(pdu2) | |
53901 | ret_val := dec_ber3(encoded_pdu, decoded_pdu) | |
53902 | if (ret_val == 0 and decoded_pdu == pdu2) {setverdict(pass)} else {setverdict(fail)} | |
53903 | encoded_pdu := '800100'O | |
53904 | ret_val := dec_ber3(encoded_pdu, decoded_pdu) | |
53905 | if (ret_val == 2) {setverdict(pass)} else {setverdict(fail)} | |
53906 | encoded_pdu := substr(enc_ber1(pdu1), 0, 4) | |
53907 | ret_val := dec_ber3(encoded_pdu, decoded_pdu) | |
53908 | if (ret_val == 2) {setverdict(pass)} else {setverdict(fail)} | |
53909 | encoded_pdu := enc_ber2(-2147483648) | |
53910 | if (encoded_pdu == '020480000000'O) {setverdict(pass)} else {setverdict(fail)} | |
53911 | encoded_pdu := enc_ber1(myrec1) | |
53912 | if (myrec1 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53913 | if ({int1 := a, int2 := b} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53914 | encoded_pdu := enc_ber1(myrec2) | |
53915 | if (myrec2 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53916 | if ({int1 := c, int2 := d} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53917 | encoded_pdu := enc_ber1(myrec3) | |
53918 | if (myrec3 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53919 | if ({int1 := 1048576, int2 := 321768} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53920 | encoded_pdu := enc_ber1(myrec4) | |
53921 | if (myrec4 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53922 | if ({65536, 131072} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53923 | encoded_pdu := enc_ber1(myrec5) | |
53924 | if (myrec5 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53925 | if ({4294967296, 8388608} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53926 | encoded_pdu := enc_ber1(myrec6) | |
53927 | if (myrec6 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53928 | if ({12345678910111213141516, 11111111111111111111} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53929 | encoded_pdu := enc_ber1(myrec7) | |
53930 | if (myrec7 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53931 | if ({8589934592, 1099511627776} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53932 | encoded_pdu := enc_ber1(myrec8) | |
53933 | if (myrec8 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53934 | if ({int1 := a, int2 := b} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53935 | encoded_pdu := enc_ber1(myrec9) | |
53936 | if (myrec9 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53937 | if ({int1 := 12345678910111213141516, int2 := -1234} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53938 | encoded_pdu := enc_ber1(myrec10) | |
53939 | if (myrec10 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53940 | if ({int1 := -12345678910111213141516, int2 := -1234} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53941 | encoded_pdu := enc_ber1(myrec11) | |
53942 | if (myrec11 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53943 | if ({2147483648, -2147483648} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53944 | encoded_pdu := enc_ber1(myrec12) | |
53945 | if (myrec12 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53946 | if ({-2147483647, 2147483647} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53947 | encoded_pdu := enc_ber1(myrec13) | |
53948 | if (myrec13 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53949 | if ({2147483649, -2147483649} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53950 | encoded_pdu := enc_ber1(myrec14) | |
53951 | if (myrec14 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53952 | if ({-4294967296, 4294967296} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53953 | encoded_pdu := enc_ber1(myrec15) | |
53954 | if (myrec15 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53955 | if ({4294967295, -4294967295} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53956 | encoded_pdu := enc_ber1(myrec16) | |
53957 | if (myrec16 == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53958 | if ({-4294967297, 4294967297} == dec_ber1(encoded_pdu)) {setverdict(pass)} else {setverdict(fail)} | |
53959 | ||
53960 | ||
53961 | <RESULT> | |
53962 | ||
53963 | Overall verdict: pass | |
53964 | ||
53965 | <END_TC> | |
53966 | ||
53967 | :exmp. | |
53968 | ||
53969 | .*---------------------------------------------------------------------* | |
53970 | :h2.Purpose | |
53971 | .*---------------------------------------------------------------------* | |
53972 | Negative tests for the BER decoder. | |
53973 | .*---------------------------------------------------------------------* | |
53974 | :h2.Test cases | |
53975 | .*---------------------------------------------------------------------* | |
53976 | ||
53977 | .*---------------------------------------------------------------------* | |
53978 | :h3. BER decoding REAL, decimal form NR3 pretending to be NR1 | |
53979 | .*---------------------------------------------------------------------* | |
53980 | :xmp tab=0. | |
53981 | ||
53982 | <TC- BER decoding REAL, decimal form NR3 pretending to be NR1> | |
53983 | ||
53984 | <STATIC:ASN> | |
53985 | ||
53986 | TempA | |
53987 | DEFINITIONS | |
53988 | AUTOMATIC TAGS | |
53989 | ::= | |
53990 | BEGIN | |
53991 | ||
53992 | IMPORTS; -- nothing | |
53993 | ||
53994 | BERPDU ::= REAL | |
53995 | ||
53996 | END | |
53997 | ||
53998 | <STATIC> | |
53999 | ||
54000 | type float BERPDU; | |
54001 | ||
54002 | external function dec_BER_PDU(in octetstring os, out BERPDU pdu) | |
54003 | with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " } | |
54004 | ||
54005 | // pi: 31415926.E-7 | |
54006 | const octetstring der_encoded := '090D0133313431353932362E452D37'O; | |
54007 | const BERPDU myValue := 3.1415926; | |
54008 | ||
54009 | <TTCN_TC:EXEC> | |
54010 | ||
54011 | var BERPDU der_decoded, cer_decoded; | |
54012 | ||
54013 | dec_BER_PDU(der_encoded, der_decoded); | |
54014 | if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);} | |
54015 | ||
54016 | <RESULT> | |
54017 | ||
54018 | Dynamic test case error: While BER-decoding type '@Temp.BERPDU': While decoding REAL type: This decimal encoding does not conform to NR1 form. | |
54019 | ||
54020 | <END_TC> | |
54021 | ||
54022 | :exmp. | |
54023 | ||
54024 | ||
54025 | .*---------------------------------------------------------------------* | |
54026 | :h3. BER decoding REAL, decimal form NR3 pretending to be NR2 | |
54027 | .*---------------------------------------------------------------------* | |
54028 | :xmp tab=0. | |
54029 | ||
54030 | <TC- BER decoding REAL, decimal form NR3 pretending to be NR2> | |
54031 | ||
54032 | <STATIC:ASN> | |
54033 | ||
54034 | TempA | |
54035 | DEFINITIONS | |
54036 | AUTOMATIC TAGS | |
54037 | ::= | |
54038 | BEGIN | |
54039 | ||
54040 | IMPORTS; -- nothing | |
54041 | ||
54042 | BERPDU ::= REAL | |
54043 | ||
54044 | END | |
54045 | ||
54046 | <STATIC> | |
54047 | ||
54048 | type float BERPDU; | |
54049 | ||
54050 | external function dec_BER_PDU(in octetstring os, out BERPDU pdu) | |
54051 | with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " } | |
54052 | ||
54053 | // pi: 31415926.E-7 | |
54054 | const octetstring der_encoded := '090D0233313431353932362E452D37'O; | |
54055 | const BERPDU myValue := 3.1415926; | |
54056 | ||
54057 | <TTCN_TC:EXEC> | |
54058 | ||
54059 | var BERPDU der_decoded, cer_decoded; | |
54060 | ||
54061 | dec_BER_PDU(der_encoded, der_decoded); | |
54062 | if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);} | |
54063 | ||
54064 | <RESULT> | |
54065 | ||
54066 | Dynamic test case error: While BER-decoding type '@Temp.BERPDU': While decoding REAL type: This decimal encoding does not conform to NR2 form. | |
54067 | ||
54068 | <END_TC> | |
54069 | ||
54070 | :exmp. | |
54071 | ||
54072 | .*---------------------------------------------------------------------* | |
54073 | :h3. BER decoding REAL, reserved decimal form 0x20 | |
54074 | .*---------------------------------------------------------------------* | |
54075 | :xmp tab=0. | |
54076 | ||
54077 | <TC- BER decoding REAL, reserved decimal form 0x20> | |
54078 | ||
54079 | <STATIC:ASN> | |
54080 | ||
54081 | TempA | |
54082 | DEFINITIONS | |
54083 | AUTOMATIC TAGS | |
54084 | ::= | |
54085 | BEGIN | |
54086 | ||
54087 | IMPORTS; -- nothing | |
54088 | ||
54089 | BERPDU ::= REAL | |
54090 | ||
54091 | END | |
54092 | ||
54093 | <STATIC> | |
54094 | ||
54095 | type float BERPDU; | |
54096 | ||
54097 | external function dec_BER_PDU(in octetstring os, out BERPDU pdu) | |
54098 | with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " } | |
54099 | ||
54100 | // pi: 31415926.E-7 | |
54101 | const octetstring der_encoded := '090D2033313431353932362E452D37'O; | |
54102 | const BERPDU myValue := 3.1415926; | |
54103 | ||
54104 | <TTCN_TC:EXEC> | |
54105 | ||
54106 | var BERPDU der_decoded, cer_decoded; | |
54107 | ||
54108 | dec_BER_PDU(der_encoded, der_decoded); | |
54109 | if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);} | |
54110 | ||
54111 | <RESULT> | |
54112 | ||
54113 | Dynamic test case error: While BER-decoding type '@Temp.BERPDU': While decoding REAL type: This is a reserved value: 0x20 (See X.690 8.5.7). | |
54114 | ||
54115 | <END_TC> | |
54116 | ||
54117 | :exmp. | |
54118 | ||
54119 | ||
54120 | .*---------------------------------------------------------------------* | |
54121 | :h3. BER decoding REAL, decimal form 0 | |
54122 | .*---------------------------------------------------------------------* | |
54123 | :xmp tab=0. | |
54124 | ||
54125 | <TC- BER decoding REAL, decimal form 0> | |
54126 | ||
54127 | <STATIC:ASN> | |
54128 | ||
54129 | TempA | |
54130 | DEFINITIONS | |
54131 | AUTOMATIC TAGS | |
54132 | ::= | |
54133 | BEGIN | |
54134 | ||
54135 | IMPORTS; -- nothing | |
54136 | ||
54137 | BERPDU ::= REAL | |
54138 | ||
54139 | END | |
54140 | ||
54141 | <STATIC> | |
54142 | ||
54143 | type float BERPDU; | |
54144 | ||
54145 | external function dec_BER_PDU(in octetstring os, out BERPDU pdu) | |
54146 | with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " } | |
54147 | ||
54148 | // pi: 31415926.E-7 | |
54149 | const octetstring der_encoded := '090D0033313431353932362E452D37'O; | |
54150 | const BERPDU myValue := 3.1415926; | |
54151 | ||
54152 | <TTCN_TC:EXEC> | |
54153 | ||
54154 | var BERPDU der_decoded, cer_decoded; | |
54155 | ||
54156 | dec_BER_PDU(der_encoded, der_decoded); | |
54157 | if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);} | |
54158 | ||
54159 | <RESULT> | |
54160 | ||
54161 | Dynamic test case error: While BER-decoding type '@Temp.BERPDU': While decoding REAL type: This is a reserved value: 0x0 (See X.690 8.5.7). | |
54162 | ||
54163 | <END_TC> | |
54164 | ||
54165 | :exmp. | |
54166 | ||
54167 | ||
54168 | .*---------------------------------------------------------------------* | |
54169 | :h3. BER decoding REAL, decimal form 4 | |
54170 | .*---------------------------------------------------------------------* | |
54171 | :xmp tab=0. | |
54172 | ||
54173 | <TC- BER decoding REAL, decimal form 4> | |
54174 | ||
54175 | <STATIC:ASN> | |
54176 | ||
54177 | TempA | |
54178 | DEFINITIONS | |
54179 | AUTOMATIC TAGS | |
54180 | ::= | |
54181 | BEGIN | |
54182 | ||
54183 | IMPORTS; -- nothing | |
54184 | ||
54185 | BERPDU ::= REAL | |
54186 | ||
54187 | END | |
54188 | ||
54189 | <STATIC> | |
54190 | ||
54191 | type float BERPDU; | |
54192 | ||
54193 | external function dec_BER_PDU(in octetstring os, out BERPDU pdu) | |
54194 | with { extension "prototype(fast) decode(BER:BER_ACCEPT_ALL) " } | |
54195 | ||
54196 | // pi: 31415926.E-7 | |
54197 | const octetstring der_encoded := '090D0433313431353932362E452D37'O; | |
54198 | const BERPDU myValue := 3.1415926; | |
54199 | ||
54200 | <TTCN_TC:EXEC> | |
54201 | ||
54202 | var BERPDU der_decoded, cer_decoded; | |
54203 | ||
54204 | dec_BER_PDU(der_encoded, der_decoded); | |
54205 | if (der_decoded==myValue) {setverdict(pass);} else {setverdict(fail);} | |
54206 | ||
54207 | <RESULT> | |
54208 | ||
54209 | Dynamic test case error: While BER-decoding type '@Temp.BERPDU': While decoding REAL type: This is a reserved value: 0x4 (See X.690 8.5.7). | |
54210 | ||
54211 | <END_TC> | |
54212 | ||
54213 | :exmp. | |
54214 | ||
54215 | .*---------------------------------------------------------------------* | |
54216 | :h3. Memory leak while BER decoding, test for HO73756 | |
54217 | .*---------------------------------------------------------------------* | |
54218 | :xmp tab=0. | |
54219 | ||
54220 | <TC - Memory leak while BER decoding, test for HO73756> | |
54221 | ||
54222 | <STATIC:ASN> | |
54223 | TempA DEFINITIONS ::= | |
54224 | BEGIN | |
54225 | ||
54226 | MY-CLASS-1 ::= CLASS | |
54227 | { | |
54228 | &TypeField OPTIONAL, | |
54229 | &fixedTypeValueField ASN1-Type1 UNIQUE OPTIONAL | |
54230 | ||
54231 | } | |
54232 | WITH SYNTAX | |
54233 | { | |
54234 | [TYPE FIELD &TypeField] | |
54235 | [FIXED VALUE TYPE FIELD &fixedTypeValueField] | |
54236 | } | |
54237 | ||
54238 | ASN1-Type1 ::= INTEGER | |
54239 | ||
54240 | ASN1-Type2 ::= BOOLEAN | |
54241 | ||
54242 | ASN1-Type3 ::= SEQUENCE {f1 INTEGER} | |
54243 | ||
54244 | ASN1-Type4 ::= OCTET STRING | |
54245 | ||
54246 | myObject-1 MY-CLASS-1 ::= | |
54247 | { | |
54248 | TYPE FIELD ASN1-Type3 | |
54249 | FIXED VALUE TYPE FIELD 999 | |
54250 | } | |
54251 | ||
54252 | myObject-2 MY-CLASS-1 ::= | |
54253 | { | |
54254 | TYPE FIELD ASN1-Type2 | |
54255 | FIXED VALUE TYPE FIELD 888 | |
54256 | } | |
54257 | ||
54258 | myObject-3 MY-CLASS-1 ::= | |
54259 | { | |
54260 | TYPE FIELD ASN1-Type4 | |
54261 | FIXED VALUE TYPE FIELD 555 | |
54262 | } | |
54263 | ||
54264 | MyInformationObjectSet1 MY-CLASS-1 ::= | |
54265 | { | |
54266 | myObject-1|myObject-2, | |
54267 | ... | |
54268 | } | |
54269 | ||
54270 | MyInformationObjectSet2 MY-CLASS-1 ::= | |
54271 | { | |
54272 | MyInformationObjectSet1|myObject-3, | |
54273 | ... | |
54274 | } | |
54275 | ||
54276 | BERPDU ::= SEQUENCE | |
54277 | { | |
54278 | field1 MY-CLASS-1.&TypeField ({MyInformationObjectSet1} {@.field2} ), | |
54279 | field2 MY-CLASS-1.&fixedTypeValueField ({MyInformationObjectSet1}) | |
54280 | } | |
54281 | ||
54282 | END | |
54283 | <STATIC> | |
54284 | // Test for memory leak problem in BER decoder: HO73756. | |
54285 | import from TempA all; | |
54286 | ||
54287 | external function dec_backtrack(in octetstring stream, out BERPDU outpdu) return integer with { extension "prototype(backtrack) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" } | |
54288 | ||
54289 | type component empty { | |
54290 | var BERPDU mypdu | |
54291 | } | |
54292 | ||
54293 | <TTCN_TC:PURE_EXEC> | |
54294 | ||
54295 | testcase mytc() runs on empty { | |
54296 | dec_backtrack('30093003020108020203E7'O, mypdu) | |
54297 | dec_backtrack('30093003020108020203E7'O, mypdu) | |
54298 | setverdict(pass) | |
54299 | } | |
54300 | ||
54301 | control { | |
54302 | execute(mytc()) | |
54303 | } | |
54304 | ||
54305 | <RESULT> | |
54306 | ||
54307 | Overall verdict: pass | |
54308 | ||
54309 | <END_TC> | |
54310 | ||
54311 | :exmp. | |
54312 | ||
54313 | .*---------------------------------------------------------------------* | |
54314 | :h1.REFERENCES | |
54315 | .*---------------------------------------------------------------------* | |
54316 | :nl. Requirement specification(s): | |
54317 | :nl.------------------------------- | |
54318 | :list. | |
54319 | :li. 8/ETH/RUS-2003:0087 Uen - Requirement Specification for TITAN's encoder/decoder functions | |
54320 | :elist. | |
54321 | ||
54322 | :etext. |