1#
2# This file is part of pyasn1 software.
3#
4# Copyright (c) 2005-2019, Ilya Etingof <[email protected]>
5# License: http://snmplabs.com/pyasn1/license.html
6#
7import sys
8
9try:
10    import unittest2 as unittest
11except ImportError:
12    import unittest
13
14from tests.base import BaseTestCase
15
16from pyasn1.type import tag
17from pyasn1.type import namedtype
18from pyasn1.type import opentype
19from pyasn1.type import univ
20from pyasn1.type import useful
21from pyasn1.codec.cer import encoder
22from pyasn1.compat.octets import ints2octs
23from pyasn1.error import PyAsn1Error
24
25
26class BooleanEncoderTestCase(BaseTestCase):
27    def testTrue(self):
28        assert encoder.encode(univ.Boolean(1)) == ints2octs((1, 1, 255))
29
30    def testFalse(self):
31        assert encoder.encode(univ.Boolean(0)) == ints2octs((1, 1, 0))
32
33
34class BitStringEncoderTestCase(BaseTestCase):
35    def testShortMode(self):
36        assert encoder.encode(
37            univ.BitString((1, 0) * 5)
38        ) == ints2octs((3, 3, 6, 170, 128))
39
40    def testLongMode(self):
41        assert encoder.encode(univ.BitString((1, 0) * 501)) == ints2octs((3, 127, 6) + (170,) * 125 + (128,))
42
43
44class OctetStringEncoderTestCase(BaseTestCase):
45    def testShortMode(self):
46        assert encoder.encode(
47            univ.OctetString('Quick brown fox')
48        ) == ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
49
50    def testLongMode(self):
51        assert encoder.encode(
52            univ.OctetString('Q' * 1001)
53        ) == ints2octs((36, 128, 4, 130, 3, 232) + (81,) * 1000 + (4, 1, 81, 0, 0))
54
55
56class GeneralizedTimeEncoderTestCase(BaseTestCase):
57    #    def testExtraZeroInSeconds(self):
58    #        try:
59    #            assert encoder.encode(
60    #                useful.GeneralizedTime('20150501120112.10Z')
61    #            )
62    #        except PyAsn1Error:
63    #            pass
64    #        else:
65    #            assert 0, 'Meaningless trailing zero in fraction part tolerated'
66
67    def testLocalTimezone(self):
68        try:
69            assert encoder.encode(
70                useful.GeneralizedTime('20150501120112.1+0200')
71            )
72        except PyAsn1Error:
73            pass
74        else:
75            assert 0, 'Local timezone tolerated'
76
77    def testMissingTimezone(self):
78        try:
79            assert encoder.encode(
80                useful.GeneralizedTime('20150501120112.1')
81            )
82        except PyAsn1Error:
83            pass
84        else:
85            assert 0, 'Missing timezone tolerated'
86
87
88    def testDecimalCommaPoint(self):
89        try:
90            assert encoder.encode(
91                useful.GeneralizedTime('20150501120112,1Z')
92             )
93        except PyAsn1Error:
94            pass
95        else:
96            assert 0, 'Decimal comma tolerated'
97
98    def testWithSubseconds(self):
99        assert encoder.encode(
100                useful.GeneralizedTime('20170801120112.59Z')
101             ) == ints2octs((24, 18, 50, 48, 49, 55, 48, 56, 48, 49, 49, 50, 48, 49, 49, 50, 46, 53, 57, 90))
102
103    def testWithSubsecondsWithZeros(self):
104        assert encoder.encode(
105                useful.GeneralizedTime('20170801120112.099Z')
106             ) == ints2octs((24, 18, 50, 48, 49, 55, 48, 56, 48, 49, 49, 50, 48, 49, 49, 50, 46, 57, 57, 90))
107
108    def testWithSubsecondsMax(self):
109        assert encoder.encode(
110                useful.GeneralizedTime('20170801120112.999Z')
111             ) == ints2octs((24, 19, 50, 48, 49, 55, 48, 56, 48, 49, 49, 50, 48, 49, 49, 50, 46, 57, 57, 57, 90))
112
113    def testWithSubsecondsMin(self):
114        assert encoder.encode(
115                useful.GeneralizedTime('20170801120112.000Z')
116             ) == ints2octs((24, 15, 50, 48, 49, 55, 48, 56, 48, 49, 49, 50, 48, 49, 49, 50, 90))
117
118    def testWithSubsecondsDanglingDot(self):
119        assert encoder.encode(
120                useful.GeneralizedTime('20170801120112.Z')
121             ) == ints2octs((24, 15, 50, 48, 49, 55, 48, 56, 48, 49, 49, 50, 48, 49, 49, 50, 90))
122
123    def testWithSeconds(self):
124        assert encoder.encode(
125                    useful.GeneralizedTime('20170801120112Z')
126             ) == ints2octs((24, 15, 50, 48, 49, 55, 48, 56, 48, 49, 49, 50, 48, 49, 49, 50, 90))
127
128    def testWithMinutes(self):
129        assert encoder.encode(
130                    useful.GeneralizedTime('201708011201Z')
131             ) == ints2octs((24, 13, 50, 48, 49, 55, 48, 56, 48, 49, 49, 50, 48, 49, 90))
132
133
134class UTCTimeEncoderTestCase(BaseTestCase):
135    def testFractionOfSecond(self):
136        try:
137            assert encoder.encode(
138                useful.UTCTime('150501120112.10Z')
139            )
140        except PyAsn1Error:
141            pass
142        else:
143            assert 0, 'Decimal point tolerated'
144
145    def testMissingTimezone(self):
146        try:
147            assert encoder.encode(
148                useful.UTCTime('150501120112')
149            ) == ints2octs((23, 13, 49, 53, 48, 53, 48, 49, 49, 50, 48, 49, 49, 50, 90))
150        except PyAsn1Error:
151            pass
152        else:
153            assert 0, 'Missing timezone tolerated'
154
155    def testLocalTimezone(self):
156        try:
157            assert encoder.encode(
158                useful.UTCTime('150501120112+0200')
159            )
160        except PyAsn1Error:
161            pass
162        else:
163            assert 0, 'Local timezone tolerated'
164
165    def testWithSeconds(self):
166        assert encoder.encode(
167                    useful.UTCTime('990801120112Z')
168             ) == ints2octs((23, 13, 57, 57, 48, 56, 48, 49, 49, 50, 48, 49, 49, 50, 90))
169
170    def testWithMinutes(self):
171        assert encoder.encode(
172                    useful.UTCTime('9908011201Z')
173             ) == ints2octs((23, 11, 57, 57, 48, 56, 48, 49, 49, 50, 48, 49, 90))
174
175
176class SequenceOfEncoderTestCase(BaseTestCase):
177    def testEmpty(self):
178        s = univ.SequenceOf()
179        s.clear()
180        assert encoder.encode(s) == ints2octs((48, 128, 0, 0))
181
182    def testDefMode1(self):
183        s = univ.SequenceOf()
184        s.append(univ.OctetString('a'))
185        s.append(univ.OctetString('ab'))
186        assert encoder.encode(s) == ints2octs((48, 128, 4, 1, 97, 4, 2, 97, 98, 0, 0))
187
188    def testDefMode2(self):
189        s = univ.SequenceOf()
190        s.append(univ.OctetString('ab'))
191        s.append(univ.OctetString('a'))
192        assert encoder.encode(s) == ints2octs((48, 128, 4, 2, 97, 98, 4, 1, 97, 0, 0))
193
194    def testDefMode3(self):
195        s = univ.SequenceOf()
196        s.append(univ.OctetString('b'))
197        s.append(univ.OctetString('a'))
198        assert encoder.encode(s) == ints2octs((48, 128, 4, 1, 98, 4, 1, 97, 0, 0))
199
200    def testDefMode4(self):
201        s = univ.SequenceOf()
202        s.append(univ.OctetString('a'))
203        s.append(univ.OctetString('b'))
204        assert encoder.encode(s) == ints2octs((48, 128, 4, 1, 97, 4, 1, 98, 0, 0))
205
206
207class SequenceOfEncoderWithSchemaTestCase(BaseTestCase):
208    def setUp(self):
209        BaseTestCase.setUp(self)
210        self.s = univ.SequenceOf(componentType=univ.OctetString())
211
212    def testEmpty(self):
213        self.s.clear()
214        assert encoder.encode(self.s) == ints2octs((48, 128, 0, 0))
215
216    def testIndefMode1(self):
217        self.s.clear()
218        self.s.append('a')
219        self.s.append('ab')
220        assert encoder.encode(self.s) == ints2octs((48, 128, 4, 1, 97, 4, 2, 97, 98, 0, 0))
221
222    def testIndefMode2(self):
223        self.s.clear()
224        self.s.append('ab')
225        self.s.append('a')
226        assert encoder.encode(self.s) == ints2octs((48, 128, 4, 2, 97, 98, 4, 1, 97, 0, 0))
227
228    def testIndefMode3(self):
229        self.s.clear()
230        self.s.append('b')
231        self.s.append('a')
232        assert encoder.encode(self.s) == ints2octs((48, 128, 4, 1, 98, 4, 1, 97, 0, 0))
233
234    def testIndefMode4(self):
235        self.s.clear()
236        self.s.append('a')
237        self.s.append('b')
238        assert encoder.encode(self.s) == ints2octs((48, 128, 4, 1, 97, 4, 1, 98, 0, 0))
239
240
241class SetOfEncoderTestCase(BaseTestCase):
242    def testEmpty(self):
243        s = univ.SetOf()
244        s.clear()
245        assert encoder.encode(s) == ints2octs((49, 128, 0, 0))
246
247    def testDefMode1(self):
248        s = univ.SetOf()
249        s.append(univ.OctetString('a'))
250        s.append(univ.OctetString('ab'))
251        assert encoder.encode(s) == ints2octs((49, 128, 4, 1, 97, 4, 2, 97, 98, 0, 0))
252
253    def testDefMode2(self):
254        s = univ.SetOf()
255        s.append(univ.OctetString('ab'))
256        s.append(univ.OctetString('a'))
257        assert encoder.encode(s) == ints2octs((49, 128, 4, 1, 97, 4, 2, 97, 98, 0, 0))
258
259    def testDefMode3(self):
260        s = univ.SetOf()
261        s.append(univ.OctetString('b'))
262        s.append(univ.OctetString('a'))
263        assert encoder.encode(s) == ints2octs((49, 128, 4, 1, 97, 4, 1, 98, 0, 0))
264
265    def testDefMode4(self):
266        s = univ.SetOf()
267        s.append(univ.OctetString('a'))
268        s.append(univ.OctetString('b'))
269        assert encoder.encode(s) == ints2octs((49, 128, 4, 1, 97, 4, 1, 98, 0, 0))
270
271
272class SetOfEncoderWithSchemaTestCase(BaseTestCase):
273    def setUp(self):
274        BaseTestCase.setUp(self)
275        self.s = univ.SetOf(componentType=univ.OctetString())
276
277    def testEmpty(self):
278        self.s.clear()
279        assert encoder.encode(self.s) == ints2octs((49, 128, 0, 0))
280
281    def testIndefMode1(self):
282        self.s.clear()
283        self.s.append('a')
284        self.s.append('ab')
285
286        assert encoder.encode(self.s) == ints2octs((49, 128, 4, 1, 97, 4, 2, 97, 98, 0, 0))
287
288    def testIndefMode2(self):
289        self.s.clear()
290        self.s.append('ab')
291        self.s.append('a')
292
293        assert encoder.encode(self.s) == ints2octs((49, 128, 4, 1, 97, 4, 2, 97, 98, 0, 0))
294
295    def testIndefMode3(self):
296        self.s.clear()
297        self.s.append('b')
298        self.s.append('a')
299
300        assert encoder.encode(self.s) == ints2octs((49, 128, 4, 1, 97, 4, 1, 98, 0, 0))
301
302    def testIndefMode4(self):
303        self.s.clear()
304        self.s.append('a')
305        self.s.append('b')
306
307        assert encoder.encode(self.s) == ints2octs((49, 128, 4, 1, 97, 4, 1, 98, 0, 0))
308
309
310class SetEncoderTestCase(BaseTestCase):
311    def setUp(self):
312        BaseTestCase.setUp(self)
313        self.s = univ.Set()
314        self.s.setComponentByPosition(0, univ.Null(''))
315        self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
316        self.s.setComponentByPosition(2, univ.Integer(1))
317
318    def testIndefMode(self):
319        assert encoder.encode(self.s) == ints2octs((49, 128, 2, 1, 1, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 5, 0, 0, 0))
320
321    def testWithOptionalIndefMode(self):
322        assert encoder.encode(
323            self.s
324        ) == ints2octs((49, 128, 2, 1, 1, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 5, 0, 0, 0))
325
326    def testWithDefaultedIndefMode(self):
327        assert encoder.encode(
328            self.s
329        ) == ints2octs((49, 128, 2, 1, 1, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 5, 0, 0, 0))
330
331    def testWithOptionalAndDefaultedIndefMode(self):
332        assert encoder.encode(
333            self.s
334        ) == ints2octs((49, 128, 2, 1, 1, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 5, 0, 0, 0))
335
336
337class SetEncoderWithSchemaTestCase(BaseTestCase):
338    def setUp(self):
339        BaseTestCase.setUp(self)
340        self.s = univ.Set(componentType=namedtype.NamedTypes(
341            namedtype.NamedType('place-holder', univ.Null('')),
342            namedtype.OptionalNamedType('first-name', univ.OctetString()),
343            namedtype.DefaultedNamedType('age', univ.Integer(33))
344        ))
345
346    def __init(self):
347        self.s.clear()
348        self.s.setComponentByPosition(0)
349
350    def __initWithOptional(self):
351        self.s.clear()
352        self.s.setComponentByPosition(0)
353        self.s.setComponentByPosition(1, 'quick brown')
354
355    def __initWithDefaulted(self):
356        self.s.clear()
357        self.s.setComponentByPosition(0)
358        self.s.setComponentByPosition(2, 1)
359
360    def __initWithOptionalAndDefaulted(self):
361        self.s.clear()
362        self.s.setComponentByPosition(0, univ.Null(''))
363        self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
364        self.s.setComponentByPosition(2, univ.Integer(1))
365
366    def testIndefMode(self):
367        self.__init()
368        assert encoder.encode(self.s) == ints2octs((49, 128, 5, 0, 0, 0))
369
370    def testWithOptionalIndefMode(self):
371        self.__initWithOptional()
372        assert encoder.encode(
373            self.s
374        ) == ints2octs((49, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 5, 0, 0, 0))
375
376    def testWithDefaultedIndefMode(self):
377        self.__initWithDefaulted()
378        assert encoder.encode(
379            self.s
380        ) == ints2octs((49, 128, 2, 1, 1, 5, 0, 0, 0))
381
382    def testWithOptionalAndDefaultedIndefMode(self):
383        self.__initWithOptionalAndDefaulted()
384        assert encoder.encode(
385            self.s
386        ) == ints2octs((49, 128, 2, 1, 1, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 5, 0, 0, 0))
387
388
389class SetEncoderWithChoiceWithSchemaEncoderTestCase(BaseTestCase):
390    def setUp(self):
391        BaseTestCase.setUp(self)
392        c = univ.Choice(componentType=namedtype.NamedTypes(
393            namedtype.NamedType('actual', univ.Boolean(0))
394        ))
395        self.s = univ.Set(componentType=namedtype.NamedTypes(
396            namedtype.NamedType('place-holder', univ.Null('')),
397            namedtype.NamedType('status', c)
398        ))
399
400    def testIndefMode(self):
401        self.s.setComponentByPosition(0)
402        self.s.setComponentByName('status')
403        self.s.getComponentByName('status').setComponentByPosition(0, 1)
404        assert encoder.encode(self.s) == ints2octs((49, 128, 1, 1, 255, 5, 0, 0, 0))
405
406
407class SetEncoderWithTaggedChoiceEncoderTestCase(BaseTestCase):
408
409    def testWithUntaggedChoice(self):
410
411        c = univ.Choice(
412            componentType=namedtype.NamedTypes(
413                namedtype.NamedType('premium', univ.Boolean())
414            )
415        )
416
417        s = univ.Set(
418            componentType=namedtype.NamedTypes(
419                namedtype.NamedType('name', univ.OctetString()),
420                namedtype.NamedType('customer', c)
421            )
422        )
423
424        s.setComponentByName('name', 'A')
425        s.getComponentByName('customer').setComponentByName('premium', True)
426
427        assert encoder.encode(s) == ints2octs((49, 128, 1, 1, 255, 4, 1, 65, 0, 0))
428
429    def testWithTaggedChoice(self):
430
431        c = univ.Choice(
432            componentType=namedtype.NamedTypes(
433                namedtype.NamedType('premium', univ.Boolean())
434            )
435        ).subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 7))
436
437        s = univ.Set(
438            componentType=namedtype.NamedTypes(
439                namedtype.NamedType('name', univ.OctetString()),
440                namedtype.NamedType('customer', c)
441            )
442        )
443
444        s.setComponentByName('name', 'A')
445        s.getComponentByName('customer').setComponentByName('premium', True)
446
447        assert encoder.encode(s) == ints2octs((49, 128, 4, 1, 65, 167, 128, 1, 1, 255, 0, 0, 0, 0))
448
449
450class SequenceEncoderTestCase(BaseTestCase):
451    def setUp(self):
452        BaseTestCase.setUp(self)
453        self.s = univ.Sequence()
454        self.s.setComponentByPosition(0, univ.Null(''))
455        self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
456        self.s.setComponentByPosition(2, univ.Integer(1))
457
458    def testIndefMode(self):
459        assert encoder.encode(self.s) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
460
461    def testWithOptionalIndefMode(self):
462        assert encoder.encode(
463            self.s
464        ) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
465
466    def testWithDefaultedIndefMode(self):
467        assert encoder.encode(
468            self.s
469        ) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
470
471    def testWithOptionalAndDefaultedIndefMode(self):
472        assert encoder.encode(
473            self.s
474        ) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
475
476
477class SequenceEncoderWithSchemaTestCase(BaseTestCase):
478    def setUp(self):
479        BaseTestCase.setUp(self)
480        self.s = univ.Sequence(
481            componentType=namedtype.NamedTypes(
482                namedtype.NamedType('place-holder', univ.Null('')),
483                namedtype.OptionalNamedType('first-name', univ.OctetString()),
484                namedtype.DefaultedNamedType('age', univ.Integer(33))
485            )
486        )
487
488    def __init(self):
489        self.s.clear()
490        self.s.setComponentByPosition(0)
491
492    def __initWithOptional(self):
493        self.s.clear()
494        self.s.setComponentByPosition(0)
495        self.s.setComponentByPosition(1, 'quick brown')
496
497    def __initWithDefaulted(self):
498        self.s.clear()
499        self.s.setComponentByPosition(0)
500        self.s.setComponentByPosition(2, 1)
501
502    def __initWithOptionalAndDefaulted(self):
503        self.s.clear()
504        self.s.setComponentByPosition(0, univ.Null(''))
505        self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
506        self.s.setComponentByPosition(2, univ.Integer(1))
507
508    def testIndefMode(self):
509        self.__init()
510        assert encoder.encode(self.s) == ints2octs((48, 128, 5, 0, 0, 0))
511
512    def testWithOptionalIndefMode(self):
513        self.__initWithOptional()
514        assert encoder.encode(
515            self.s
516        ) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
517
518    def testWithDefaultedIndefMode(self):
519        self.__initWithDefaulted()
520        assert encoder.encode(
521            self.s
522        ) == ints2octs((48, 128, 5, 0, 2, 1, 1, 0, 0))
523
524    def testWithOptionalAndDefaultedIndefMode(self):
525        self.__initWithOptionalAndDefaulted()
526        assert encoder.encode(
527            self.s
528        ) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
529
530
531class SequenceEncoderWithUntaggedOpenTypesTestCase(BaseTestCase):
532    def setUp(self):
533        BaseTestCase.setUp(self)
534
535        openType = opentype.OpenType(
536            'id',
537            {1: univ.Integer(),
538             2: univ.OctetString()}
539        )
540        self.s = univ.Sequence(
541            componentType=namedtype.NamedTypes(
542                namedtype.NamedType('id', univ.Integer()),
543                namedtype.NamedType('blob', univ.Any(), openType=openType)
544            )
545        )
546
547    def testEncodeOpenTypeChoiceOne(self):
548        self.s.clear()
549
550        self.s[0] = 1
551        self.s[1] = univ.Integer(12)
552
553        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
554            (48, 128, 2, 1, 1, 49, 50, 0, 0)
555        )
556
557    def testEncodeOpenTypeChoiceTwo(self):
558        self.s.clear()
559
560        self.s[0] = 2
561        self.s[1] = univ.OctetString('quick brown')
562
563        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
564            (48, 128, 2, 1, 2, 113, 117, 105, 99, 107, 32, 98, 114,
565             111, 119, 110, 0, 0)
566        )
567
568    def testEncodeOpenTypeUnknownId(self):
569        self.s.clear()
570
571        self.s[0] = 2
572        self.s[1] = univ.ObjectIdentifier('1.3.6')
573
574        try:
575            encoder.encode(self.s, asn1Spec=self.s)
576
577        except PyAsn1Error:
578            assert False, 'incompatible open type tolerated'
579
580    def testEncodeOpenTypeIncompatibleType(self):
581        self.s.clear()
582
583        self.s[0] = 2
584        self.s[1] = univ.ObjectIdentifier('1.3.6')
585
586        try:
587            encoder.encode(self.s, asn1Spec=self.s)
588
589        except PyAsn1Error:
590            assert False, 'incompatible open type tolerated'
591
592
593class SequenceEncoderWithImplicitlyTaggedOpenTypesTestCase(BaseTestCase):
594    def setUp(self):
595        BaseTestCase.setUp(self)
596
597        openType = opentype.OpenType(
598            'id',
599            {1: univ.Integer(),
600             2: univ.OctetString()}
601        )
602        self.s = univ.Sequence(
603            componentType=namedtype.NamedTypes(
604                namedtype.NamedType('id', univ.Integer()),
605                namedtype.NamedType('blob', univ.Any().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3)), openType=openType)
606            )
607        )
608
609    def testEncodeOpenTypeChoiceOne(self):
610        self.s.clear()
611
612        self.s[0] = 1
613        self.s[1] = univ.Integer(12)
614
615        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
616            (48, 128, 2, 1, 1, 163, 128, 163, 128, 49, 50, 0, 0, 0, 0, 0, 0)
617        )
618
619
620class SequenceEncoderWithExplicitlyTaggedOpenTypesTestCase(BaseTestCase):
621    def setUp(self):
622        BaseTestCase.setUp(self)
623
624        openType = opentype.OpenType(
625            'id',
626            {1: univ.Integer(),
627             2: univ.OctetString()}
628        )
629        self.s = univ.Sequence(
630            componentType=namedtype.NamedTypes(
631                namedtype.NamedType('id', univ.Integer()),
632                namedtype.NamedType('blob', univ.Any().subtype(explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3)), openType=openType)
633            )
634        )
635
636    def testEncodeOpenTypeChoiceOne(self):
637        self.s.clear()
638
639        self.s[0] = 1
640        self.s[1] = univ.Integer(12)
641
642        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
643            (48, 128, 2, 1, 1, 163, 128, 163, 128, 49, 50, 0, 0, 0, 0, 0, 0)
644        )
645
646
647class SequenceEncoderWithUntaggedSetOfOpenTypesTestCase(BaseTestCase):
648    def setUp(self):
649        BaseTestCase.setUp(self)
650
651        openType = opentype.OpenType(
652            'id',
653            {1: univ.Integer(),
654             2: univ.OctetString()}
655        )
656        self.s = univ.Sequence(
657            componentType=namedtype.NamedTypes(
658                namedtype.NamedType('id', univ.Integer()),
659                namedtype.NamedType('blob', univ.SetOf(
660                    componentType=univ.Any()), openType=openType)
661            )
662        )
663
664    def testEncodeOpenTypeChoiceOne(self):
665        self.s.clear()
666
667        self.s[0] = 1
668        self.s[1].append(univ.Integer(12))
669
670        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
671            (48, 128, 2, 1, 1, 49, 128, 49, 50, 0, 0, 0, 0)
672        )
673
674    def testEncodeOpenTypeChoiceTwo(self):
675        self.s.clear()
676
677        self.s[0] = 2
678        self.s[1].append(univ.OctetString('quick brown'))
679
680        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
681            (48, 128, 2, 1, 2, 49, 128, 113, 117, 105, 99, 107, 32, 98, 114,
682             111, 119, 110, 0, 0, 0, 0)
683        )
684
685    def testEncodeOpenTypeUnknownId(self):
686        self.s.clear()
687
688        self.s[0] = 2
689        self.s[1].append(univ.ObjectIdentifier('1.3.6'))
690
691        try:
692            encoder.encode(self.s, asn1Spec=self.s)
693
694        except PyAsn1Error:
695            assert False, 'incompatible open type tolerated'
696
697    def testEncodeOpenTypeIncompatibleType(self):
698        self.s.clear()
699
700        self.s[0] = 2
701        self.s[1].append(univ.ObjectIdentifier('1.3.6'))
702
703        try:
704            encoder.encode(self.s, asn1Spec=self.s)
705
706        except PyAsn1Error:
707            assert False, 'incompatible open type tolerated'
708
709
710class SequenceEncoderWithImplicitlyTaggedSetOfOpenTypesTestCase(BaseTestCase):
711    def setUp(self):
712        BaseTestCase.setUp(self)
713
714        openType = opentype.OpenType(
715            'id',
716            {1: univ.Integer(),
717             2: univ.OctetString()}
718        )
719        self.s = univ.Sequence(
720            componentType=namedtype.NamedTypes(
721                namedtype.NamedType('id', univ.Integer()),
722                namedtype.NamedType('blob', univ.SetOf(
723                    componentType=univ.Any().subtype(
724                        implicitTag=tag.Tag(
725                            tag.tagClassContext, tag.tagFormatSimple, 3))),
726                    openType=openType)
727            )
728        )
729
730    def testEncodeOpenTypeChoiceOne(self):
731        self.s.clear()
732
733        self.s[0] = 1
734        self.s[1].append(univ.Integer(12))
735
736        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
737            (48, 128, 2, 1, 1, 49, 128, 163, 128, 163, 128, 49, 50, 0, 0,
738             0, 0, 0, 0, 0, 0)
739        )
740
741
742class SequenceEncoderWithExplicitlyTaggedSetOfOpenTypesTestCase(BaseTestCase):
743    def setUp(self):
744        BaseTestCase.setUp(self)
745
746        openType = opentype.OpenType(
747            'id',
748            {1: univ.Integer(),
749             2: univ.OctetString()}
750        )
751        self.s = univ.Sequence(
752            componentType=namedtype.NamedTypes(
753                namedtype.NamedType('id', univ.Integer()),
754                namedtype.NamedType('blob', univ.SetOf(
755                    componentType=univ.Any().subtype(
756                        explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3))),
757                    openType=openType)
758            )
759        )
760
761    def testEncodeOpenTypeChoiceOne(self):
762        self.s.clear()
763
764        self.s[0] = 1
765        self.s[1].append(univ.Integer(12))
766
767        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
768            (48, 128, 2, 1, 1, 49, 128, 163, 128, 163, 128, 49, 50, 0, 0,
769             0, 0, 0, 0, 0, 0)
770        )
771
772
773class NestedOptionalSequenceEncoderTestCase(BaseTestCase):
774    def setUp(self):
775        BaseTestCase.setUp(self)
776        inner = univ.Sequence(
777            componentType=namedtype.NamedTypes(
778                namedtype.OptionalNamedType('first-name', univ.OctetString()),
779                namedtype.DefaultedNamedType('age', univ.Integer(33)),
780            )
781        )
782
783        outerWithOptional = univ.Sequence(
784            componentType=namedtype.NamedTypes(
785                namedtype.OptionalNamedType('inner', inner),
786            )
787        )
788
789        outerWithDefault = univ.Sequence(
790            componentType=namedtype.NamedTypes(
791                namedtype.DefaultedNamedType('inner', inner),
792            )
793        )
794
795        self.s1 = outerWithOptional
796        self.s2 = outerWithDefault
797
798    def __initOptionalWithDefaultAndOptional(self):
799        self.s1.clear()
800        self.s1[0][0] = 'test'
801        self.s1[0][1] = 123
802        return self.s1
803
804    def __initOptionalWithDefault(self):
805        self.s1.clear()
806        self.s1[0][1] = 123
807        return self.s1
808
809    def __initOptionalWithOptional(self):
810        self.s1.clear()
811        self.s1[0][0] = 'test'
812        return self.s1
813
814    def __initOptional(self):
815        self.s1.clear()
816        return self.s1
817
818    def __initDefaultWithDefaultAndOptional(self):
819        self.s2.clear()
820        self.s2[0][0] = 'test'
821        self.s2[0][1] = 123
822        return self.s2
823
824    def __initDefaultWithDefault(self):
825        self.s2.clear()
826        self.s2[0][0] = 'test'
827        return self.s2
828
829    def __initDefaultWithOptional(self):
830        self.s2.clear()
831        self.s2[0][1] = 123
832        return self.s2
833
834    def testOptionalWithDefaultAndOptional(self):
835        s = self.__initOptionalWithDefaultAndOptional()
836        assert encoder.encode(s) == ints2octs((48, 128, 48, 128, 4, 4, 116, 101, 115, 116, 2, 1, 123, 0, 0, 0, 0))
837
838    def testOptionalWithDefault(self):
839        s = self.__initOptionalWithDefault()
840        assert encoder.encode(s) == ints2octs((48, 128, 48, 128, 2, 1, 123, 0, 0, 0, 0))
841
842    def testOptionalWithOptional(self):
843        s = self.__initOptionalWithOptional()
844        assert encoder.encode(s) == ints2octs((48, 128, 48, 128, 4, 4, 116, 101, 115, 116, 0, 0, 0, 0))
845
846    def testOptional(self):
847        s = self.__initOptional()
848        assert encoder.encode(s) == ints2octs((48, 128, 0, 0))
849
850    def testDefaultWithDefaultAndOptional(self):
851        s = self.__initDefaultWithDefaultAndOptional()
852        assert encoder.encode(s) == ints2octs((48, 128, 48, 128, 4, 4, 116, 101, 115, 116, 2, 1, 123, 0, 0, 0, 0))
853
854    def testDefaultWithDefault(self):
855        s = self.__initDefaultWithDefault()
856        assert encoder.encode(s) == ints2octs((48, 128, 48, 128, 4, 4, 116, 101, 115, 116, 0, 0, 0, 0))
857
858    def testDefaultWithOptional(self):
859        s = self.__initDefaultWithOptional()
860        assert encoder.encode(s) == ints2octs((48, 128, 48, 128, 2, 1, 123, 0, 0, 0, 0))
861
862
863class NestedOptionalChoiceEncoderTestCase(BaseTestCase):
864    def setUp(self):
865        BaseTestCase.setUp(self)
866        layer3 = univ.Sequence(
867            componentType=namedtype.NamedTypes(
868                namedtype.OptionalNamedType('first-name', univ.OctetString()),
869                namedtype.DefaultedNamedType('age', univ.Integer(33)),
870            )
871        )
872
873        layer2 = univ.Choice(
874            componentType=namedtype.NamedTypes(
875                namedtype.NamedType('inner', layer3),
876                namedtype.NamedType('first-name', univ.OctetString())
877            )
878        )
879
880        layer1 = univ.Sequence(
881            componentType=namedtype.NamedTypes(
882                namedtype.OptionalNamedType('inner', layer2),
883            )
884        )
885
886        self.s = layer1
887
888    def __initOptionalWithDefaultAndOptional(self):
889        self.s.clear()
890        self.s[0][0][0] = 'test'
891        self.s[0][0][1] = 123
892        return self.s
893
894    def __initOptionalWithDefault(self):
895        self.s.clear()
896        self.s[0][0][1] = 123
897        return self.s
898
899    def __initOptionalWithOptional(self):
900        self.s.clear()
901        self.s[0][0][0] = 'test'
902        return self.s
903
904    def __initOptional(self):
905        self.s.clear()
906        return self.s
907
908    def testOptionalWithDefaultAndOptional(self):
909        s = self.__initOptionalWithDefaultAndOptional()
910        assert encoder.encode(s) == ints2octs((48, 128, 48, 128, 4, 4, 116, 101, 115, 116, 2, 1, 123, 0, 0, 0, 0))
911
912    def testOptionalWithDefault(self):
913        s = self.__initOptionalWithDefault()
914        assert encoder.encode(s) == ints2octs((48, 128, 48, 128, 2, 1, 123, 0, 0, 0, 0))
915
916    def testOptionalWithOptional(self):
917        s = self.__initOptionalWithOptional()
918        assert encoder.encode(s) == ints2octs((48, 128, 48, 128, 4, 4, 116, 101, 115, 116, 0, 0, 0, 0))
919
920    def testOptional(self):
921        s = self.__initOptional()
922        assert encoder.encode(s) == ints2octs((48, 128, 0, 0))
923
924
925class NestedOptionalSequenceOfEncoderTestCase(BaseTestCase):
926    def setUp(self):
927        BaseTestCase.setUp(self)
928        layer2 = univ.SequenceOf(
929            componentType=univ.OctetString()
930        )
931
932        layer1 = univ.Sequence(
933            componentType=namedtype.NamedTypes(
934                namedtype.OptionalNamedType('inner', layer2),
935            )
936        )
937
938        self.s = layer1
939
940    def __initOptionalWithValue(self):
941        self.s.clear()
942        self.s[0][0] = 'test'
943        return self.s
944
945    def __initOptional(self):
946        self.s.clear()
947        return self.s
948
949    def testOptionalWithValue(self):
950        s = self.__initOptionalWithValue()
951        assert encoder.encode(s) == ints2octs((48, 128, 48, 128, 4, 4, 116, 101, 115, 116, 0, 0, 0, 0))
952
953    def testOptional(self):
954        s = self.__initOptional()
955        assert encoder.encode(s) == ints2octs((48, 128, 0, 0))
956
957
958suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
959
960if __name__ == '__main__':
961    unittest.TextTestRunner(verbosity=2).run(suite)
962