![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bigpepytest.py CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepy|
Return to bigpepytest.py CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepy |
1.1 root 1: -- bigpepytest.py - test out most of the pepy constructs
2:
3: -- $Header: /f/osi/pepy/RCS/bigpepytest.py,v 7.0 89/11/23 22:11:37 mrose Rel $
4: --
5: --
6: -- $Log: bigpepytest.py,v $
7: -- Revision 7.0 89/11/23 22:11:37 mrose
8: -- Release 6.0
9: --
10:
11: --
12: -- NOTICE
13: --
14: -- Acquisition, use, and distribution of this module and related
15: -- materials are subject to the restrictions of a license agreement.
16: -- Consult the Preface in the User's Manual for the full terms of
17: -- this agreement.
18: --
19: --
20:
21:
22: BigTest DEFINITIONS ::=
23:
24: %{
25: #ifndef lint
26: static char *rcsid = "$Header: /f/osi/pepy/RCS/bigpepytest.py,v 7.0 89/11/23 22:11:37 mrose Rel $";
27: #endif
28:
29: #include <stdio.h>
30:
31:
32: static int count;
33:
34: static char *myname = "bigpepytest";
35:
36:
37: void adios ();
38:
39: /* */
40:
41: /* ARGSUSED */
42:
43: main (argc, argv, envp)
44: int argc;
45: char **argv,
46: **envp;
47: {
48: PE pe;
49:
50: myname = argv[0];
51:
52: if (encoder_BigTest_Test1 (&pe, 1, NULL, NULLCP, NULLCP) == NOTOK)
53: adios (NULLCP, "encoder fails");
54:
55: if (printer_BigTest_Test1 (pe, 1, NULLIP, NULLVP, NULLCP) == NOTOK)
56: adios (NULLCP, "printer fails");
57:
58: if (decoder_BigTest_Test1 (pe, 1, NULLIP, NULLVP, NULLCP) == NOTOK)
59: adios (NULLCP, "decoder fails");
60:
61: exit (0); /* NOTREACHED */
62: }
63: %}
64:
65: BEGIN
66:
67:
68: ENCODER encoder
69:
70: Test1 %{ int fd = rnd (2); %} ::=
71: SEQUENCE {
72: boolean
73: BOOLEAN
74: [[b rnd(2)]],
75:
76: taggedBoolean
77: [0] BOOLEAN
78: [[b rnd (2)]],
79:
80: implicitTaggedBoolean
81: [PRIVATE 0] IMPLICIT BOOLEAN
82: [[b rnd(2)]],
83:
84: integer
85: INTEGER
86: [[i rnd(10000)]],
87:
88: taggedInteger
89: [APPLICATION 1] INTEGER
90: [[i rnd(10000)]],
91:
92: implicitTaggedInteger
93: [UNIVERSAL 1] IMPLICIT INTEGER
94: [[i rnd(10000)]],
95:
96: integerOneValue
97: INTEGER
98: [[i 1]] { nn(1) },
99:
100: taggedIntegerOneValue
101: [PRIVATE 2] INTEGER
102: [[i 1]] { nn(1) },
103:
104: integerManyValues
105: INTEGER
106: [[i rnd(3) + 1]]
107: { nn1(1), nn2(2), nn3(3) },
108:
109: implicitTaggedIntegerManyValues
110: [2] IMPLICIT INTEGER
111: [[i rnd(3) + 1]]
112: { nn1(1), nn2(2), nn3(3) },
113:
114: bitstring
115: %{
116: int i;
117: $$ = pe_alloc(PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_BITS);
118: $$ = prim2bit($$);
119: for(i = 0; i < 32; i++)
120: if( rnd(2) )
121: (void) bit_on($$, i);
122: %}
123: BITSTRING,
124:
125: taggedBitstring [UNIVERSAL 3]
126: %{
127: int i;
128: $$ = pe_alloc(PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_BITS);
129: $$ = prim2bit($$);
130: for(i = 0; i < 32; i++)
131: if( rnd(2) && rnd(3) )
132: (void) bit_on($$, i);
133: %}
134: BITSTRING,
135:
136: bitstring2
137: BIT STRING
138: [[x int2strb(0177, 8) $ 8]],
139:
140: taggedBitstring2
141: [4] BIT STRING
142: [[x int2strb(0177, 8) $ 8]],
143:
144: implicitTaggedBitstring2
145: [PRIVATE 4] IMPLICIT BIT STRING
146: [[x int2strb(0xffff, 16) $ 16]],
147:
148: bitstringValue
149: BIT STRING
150: [[x int2strb(1, 1) $ 1]]
151: { nn1(1) },
152:
153: taggedBitstringValue
154: [APPLICATION 5] BIT STRING
155: [[x int2strb(1, 1) $ 1]]
156: { nn1(1) },
157:
158: bitstringValues
159: BIT STRING
160: [[x int2strb(03, 3) $ 3]]
161: { nn1(1), nn2(2), nn3(3) },
162:
163: taggedBitstringValues
164: [PRIVATE 6] BIT STRING
165: [[x int2strb(03, 3) $ 3]]
166: { nn1(1), nn2(2), nn3(3) },
167:
168: implicitTaggedBitstringValues
169: [APPLICATION 6] IMPLICIT BIT STRING
170: [[x int2strb(03, 3) $ 3]]
171: { nn1(1), nn2(2), nn3(3) },
172:
173: octetstring
174: OCTET STRING
175: [[s "hello world"]],
176:
177: taggedOctetstring
178: [UNIVERSAL 7] OCTET STRING
179: [[s "hello world"]],
180:
181: octetstring2
182: OCTETSTRING
183: [[s "goodbye world"]],
184:
185: implicitTaggedOctetstring2
186: [PRIVATE 7] IMPLICIT OCTETSTRING
187: [[o "goodbye world" $ 8]],
188:
189: null
190: NULL,
191:
192: taggedNull
193: [8] NULL,
194:
195: implicitTaggedNull
196: [PRIVATE 8] IMPLICIT NULL,
197:
198: sequence
199: SEQUENCE,
200:
201: taggedSequence
202: [APPLICATION 9] SEQUENCE,
203:
204: implicitTaggedSequence
205: [PRIVATE 9] SEQUENCE,
206:
207: sequenceOf
208: SEQUENCE OF
209: <<count = rnd(10); count >= 0; count-->>
210: SequenceA,
211:
212: taggedSequenceOf
213: [PRIVATE 10] SEQUENCE OF
214: <<count = rnd(10); count >= 0; count-->>
215: SequenceA,
216:
217: sequenceOf2
218: SEQUENCEOF
219: <<count = rnd(3); count >= 0; count-->>
220: SequenceB,
221:
222: implicitTaggedSequenceOf2
223: [10] IMPLICIT SEQUENCEOF
224: <<count = rnd(3); count >= 0; count-->>
225: SequenceA,
226:
227: set
228: SET,
229:
230: taggedSet
231: [UNIVERSAL 11] SET,
232:
233: implicitTaggedSet
234: [PRIVATE 11] IMPLICIT SET,
235:
236: setOf
237: SET OF
238: <<count = rnd(10); count >= 0; count -->>
239: SetA,
240:
241: taggedSetOf
242: [12] SET OF
243: <<count = rnd(10); count >= 0; count -->>
244: SetA,
245:
246: setOf2
247: SETOF
248: <<count = rnd(4); count >= 0; count -->>
249: SetB,
250:
251: implicitTaggedSetOf2
252: [PRIVATE 12] IMPLICIT SETOF
253: <<count = rnd(4); count >= 0; count -->>
254: SetA,
255:
256: setValues
257: SET { SequenceA, SequenceB, SetA, SetB },
258:
259: taggedSetValues
260: [APPLICATION 13] SET { SequenceA, SequenceB, SetA, SetB },
261:
262: implicitTaggedSetValues
263: [13] IMPLICIT SET { SequenceA, SequenceB, SetA, SetB },
264:
265: choice
266: CHOICE << rnd(2) + 1 >> {
267: [1]
268: SequenceA,
269:
270: [2]
271: SequenceB,
272:
273: [3]
274: SetA,
275:
276: [4]
277: SetB
278: },
279:
280: taggedChoice
281: [PRIVATE 14] CHOICE << rnd(2) + 1 >> {
282: [1]
283: SequenceA,
284:
285: [2]
286: SequenceB,
287:
288: [3]
289: SetA,
290:
291: [4]
292: SetB
293: },
294:
295: bounded
296: objectname < ObjectA,
297:
298: taggedBounded
299: [UNIVERSAL 15] objectname < ObjectA,
300:
301: any
302: ANY
303: [[a pe_alloc (PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_NULL)]],
304:
305: taggedAny [PRIVATE 15]
306: ANY
307: [[a pe_alloc (PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_NULL)]],
308:
309: oid
310: %{
311: OID oid;
312: register int i;
313:
314: oid = (OID) calloc (1, sizeof(OIDentifier));
315: oid->oid_nelem = rnd(6)+2;
316: oid->oid_elements = (unsigned int *)
317: calloc((unsigned) oid->oid_nelem,
318: sizeof(unsigned int));
319: for(i = 0; i < oid->oid_nelem; i++)
320: oid->oid_elements[i] = rnd(10);
321: $$ = oid;
322: %}
323: OBJECT IDENTIFIER,
324:
325: taggedOid [16]
326: %{
327: OID oid;
328: register int i;
329:
330: oid = (OID) calloc (1, sizeof(OIDentifier));
331: oid->oid_nelem = rnd(6)+2;
332: oid->oid_elements = (unsigned int *)
333: calloc((unsigned) oid->oid_nelem,
334: sizeof(unsigned int));
335: for(i = 0; i < oid->oid_nelem; i++)
336: oid->oid_elements[i] = rnd(10);
337: $$ = oid;
338: %}
339: OBJECT IDENTIFIER,
340:
341: oid2
342: OBJECT IDENTIFIER
343: [[O str2oid ("1.2.3.4.5.6.7.8.9")]],
344:
345: implicitTaggedOid2
346: [APPLICATION 17] IMPLICIT OBJECT IDENTIFIER
347: [[O str2oid ("1.2.3.4.5.6.7.8.9")]],
348:
349: funnyDefault
350: [18] IMPLICIT INTEGER
351: [[i fd]]
352: DEFAULT 0 << fd != 0 >>
353: }
354:
355: SequenceA ::=
356: SEQUENCE {
357: seqAinteger
358: INTEGER
359: [[i rnd(50)]],
360:
361: seqAbool
362: BOOLEAN
363: [[b rnd(2)]]
364: }
365:
366: SequenceB ::=
367: [PRIVATE 100] SEQUENCE {
368: seqBinteger
369: INTEGER
370: [[i rnd(75)]]
371: }
372:
373: SetA ::=
374: SET {
375: setAinteger
376: INTEGER
377: [[i rnd(20000)]],
378:
379: setAbool
380: BOOLEAN
381: [[b rnd(2)]]
382: }
383:
384: SetB ::=
385: [PRIVATE 101] SET {
386: setBinteger
387: INTEGER
388: [[i rnd(3000)]]
389: }
390:
391: ObjectA ::=
392: BOOLEAN
393: [[b rnd(2)]]
394:
395:
396: SECTIONS none decoder printer
397:
398: Test1 ::=
399: SEQUENCE {
400: boolean
401: BOOLEAN,
402:
403: taggedBoolean
404: [0] BOOLEAN,
405:
406: implicitTaggedBoolean
407: [PRIVATE 0] IMPLICIT BOOLEAN,
408:
409: integer
410: INTEGER,
411:
412: taggedInteger
413: [APPLICATION 1] INTEGER,
414:
415: implicitTaggedInteger
416: [UNIVERSAL 1] IMPLICIT INTEGER,
417:
418: integerOneValue
419: INTEGER { nn(1) },
420:
421: taggedIntegerOneValue
422: [PRIVATE 2] INTEGER { nn(1) },
423:
424: integerManyValues
425: INTEGER { nn1(1), nn2(2), nn3(3) },
426:
427: implicitTaggedIntegerManyValues
428: [2] IMPLICIT INTEGER { nn1(1), nn2(2), nn3(3) },
429:
430: bitstring
431: BITSTRING,
432:
433: taggedBitString
434: [UNIVERSAL 3] BITSTRING,
435:
436: bitstring2
437: BIT STRING,
438:
439: taggedBitstring2
440: [4] BIT STRING,
441:
442: implictTaggedBitstring2
443: [PRIVATE 4] IMPLICIT BIT STRING,
444:
445: bitstringValue
446: BIT STRING { nn1(1) },
447:
448: taggedBitstringValue
449: [APPLICATION 5] BIT STRING { nn1(1) },
450:
451: bitstringValues
452: BIT STRING { nn1(1), nn2(2), nn3(3) },
453:
454: taggedBitstringValues
455: [PRIVATE 6] BIT STRING { nn1(1), nn2(2), nn3(3) },
456:
457: implicitTaggedBitstringValues
458: [APPLICATION 6] IMPLICIT BIT STRING
459: { nn1(1), nn2(2), nn3(3) },
460:
461: octetstring
462: OCTET STRING,
463:
464: taggedOctetstring
465: [UNIVERSAL 7] OCTET STRING,
466:
467: octetstring2
468: OCTETSTRING,
469:
470: implicitTaggedOctetstring2
471: [PRIVATE 7] IMPLICIT OCTETSTRING,
472:
473: null
474: NULL,
475:
476: taggedNull
477: [8] NULL,
478:
479: implicitTaggedNull
480: [PRIVATE 8] IMPLICIT NULL,
481:
482: sequence
483: SEQUENCE,
484:
485: taggedSequence
486: [APPLICATION 9] SEQUENCE,
487:
488: implicitTaggedSequence
489: [PRIVATE 9] IMPLICIT SEQUENCE,
490:
491: sequenceOf
492: SEQUENCE OF
493: SequenceA,
494:
495: taggedSequenceOf
496: [PRIVATE 10] SEQUENCE OF
497: SequenceA,
498:
499: sequenceOf2
500: SEQUENCEOF
501: SequenceB,
502:
503: implicitTaggedSequenceOf2
504: [10] IMPLICIT SEQUENCEOF
505: SequenceA,
506:
507: set
508: SET,
509:
510: taggedSet
511: [UNIVERSAL 11] SET,
512:
513: implicitTaggedSet
514: [PRIVATE 11] IMPLICIT SET,
515:
516: setOf
517: SET OF
518: SetA,
519:
520: taggedSetOf
521: [12] SET OF
522: SetA,
523:
524: setOf2
525: SETOF
526: SetB,
527:
528: implicitTaggedSetOf2
529: [PRIVATE 12] IMPLICIT SETOF
530: SetA,
531:
532: setValues
533: SET { SequenceA, SequenceB, SetA, SetB },
534:
535: taggedSetValues
536: [APPLICATION 13] SET { SequenceA, SequenceB, SetA, SetB },
537:
538: implicitTaggedSetValues
539: [13] IMPLICIT SET { SequenceA, SequenceB, SetA, SetB },
540:
541: choice
542: CHOICE {
543: [1]
544: SequenceA,
545:
546: [2]
547: SequenceB,
548:
549: [3]
550: SetA,
551:
552: [4]
553: SetB
554: },
555:
556: taggedChoice
557: [PRIVATE 14] CHOICE {
558: [1]
559: SequenceA,
560:
561: [2]
562: SequenceB,
563:
564: [3]
565: SetA,
566:
567: [4]
568: SetB
569: },
570:
571: bounded
572: objectname < ObjectA,
573:
574: taggedBounded
575: [UNIVERSAL 15] objectname < ObjectA,
576:
577: any
578: ANY,
579:
580: taggedAny
581: [PRIVATE 15] ANY,
582:
583: oid
584: OBJECT IDENTIFIER,
585:
586: taggedOid
587: [16] OBJECT IDENTIFIER,
588:
589: oid2
590: OBJECT IDENTIFIER,
591:
592: implicitTaggedOid2
593: [APPLICATION 17] IMPLICIT OBJECT IDENTIFIER,
594:
595: funnyDefault
596: [18] IMPLICIT INTEGER
597: %{ if ($$ == 0) advise (NULLCP, "funny default!"); %}
598: DEFAULT 0
599: }
600:
601: SequenceA ::=
602: SEQUENCE {
603: seqAinteger
604: INTEGER,
605:
606: seqAbool
607: BOOLEAN
608: }
609:
610: SequenceB ::=
611: [PRIVATE 100] SEQUENCE {
612: seqBinteger
613: INTEGER
614: }
615:
616: SetA ::=
617: SET {
618: setAinteger
619: INTEGER,
620:
621: setAbool
622: BOOLEAN
623: }
624:
625: SetB ::=
626: [PRIVATE 101] SET {
627: setBinteger
628: INTEGER
629: }
630:
631: ObjectA ::=
632: BOOLEAN
633:
634:
635: END
636:
637: %{
638:
639: /* MISC */
640:
641: #ifdef BSD42
642: #define SRAND(s) srandom ((int) (s))
643: #define RAND random
644:
645: long random ();
646: #else
647: #define SRAND srand
648: #define RAND rand
649:
650: int rand ();
651: #endif
652:
653: long time ();
654:
655:
656: static int rnd(n)
657: int n;
658: {
659: static int init = 0;
660:
661: if (!init) {
662: SRAND (time ((long *) 0));
663: init = 1;
664: }
665: return (RAND () % n);
666: }
667:
668: /* ERRORS */
669:
670: #include <varargs.h>
671:
672:
673: #ifndef lint
674: void _advise ();
675:
676:
677: static void adios (va_alist)
678: va_dcl
679: {
680: va_list ap;
681:
682: va_start (ap);
683:
684: _advise (ap);
685:
686: va_end (ap);
687:
688: _exit (1);
689: }
690: #else
691: /* VARARGS */
692:
693: static void adios (what, fmt)
694: char *what,
695: *fmt;
696: {
697: adios (what, fmt);
698: }
699: #endif
700:
701:
702: #ifndef lint
703: static void advise (va_alist)
704: va_dcl
705: {
706: va_list ap;
707:
708: va_start (ap);
709:
710: _advise (ap);
711:
712: va_end (ap);
713: }
714:
715:
716: static void _advise (ap)
717: va_list ap;
718: {
719: char buffer[BUFSIZ];
720:
721: asprintf (buffer, ap);
722:
723: (void) fflush (stdout);
724:
725: fprintf (stderr, "%s: ", myname);
726: (void) fputs (buffer, stderr);
727: (void) fputc ('\n', stderr);
728:
729: (void) fflush (stderr);
730: }
731: #else
732: /* VARARGS */
733:
734: static void advise (what, fmt)
735: char *what,
736: *fmt;
737: {
738: advise (what, fmt);
739: }
740: #endif
741:
742: %}
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.