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
11
12except ImportError:
13    import unittest
14
15from tests.base import BaseTestCase
16
17from pyasn1.type import tag
18from pyasn1.type import namedtype
19from pyasn1.type import opentype
20from pyasn1.type import univ
21from pyasn1.type import char
22from pyasn1.codec.ber import encoder
23from pyasn1.compat.octets import ints2octs
24from pyasn1.error import PyAsn1Error
25
26
27class LargeTagEncoderTestCase(BaseTestCase):
28    def setUp(self):
29        BaseTestCase.setUp(self)
30
31        self.o = univ.Integer().subtype(
32            value=1, explicitTag=tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 0xdeadbeaf)
33        )
34
35    def testEncoder(self):
36        assert encoder.encode(self.o) == ints2octs((127, 141, 245, 182, 253, 47, 3, 2, 1, 1))
37
38
39class IntegerEncoderTestCase(BaseTestCase):
40    def testPosInt(self):
41        assert encoder.encode(univ.Integer(12)) == ints2octs((2, 1, 12))
42
43    def testNegInt(self):
44        assert encoder.encode(univ.Integer(-12)) == ints2octs((2, 1, 244))
45
46    def testZero(self):
47        assert encoder.encode(univ.Integer(0)) == ints2octs((2, 1, 0))
48
49    def testCompactZero(self):
50        encoder.IntegerEncoder.supportCompactZero = True
51        substrate = encoder.encode(univ.Integer(0))
52        encoder.IntegerEncoder.supportCompactZero = False
53        assert substrate == ints2octs((2, 0))
54
55    def testMinusOne(self):
56        assert encoder.encode(univ.Integer(-1)) == ints2octs((2, 1, 255))
57
58    def testPosLong(self):
59        assert encoder.encode(
60            univ.Integer(0xffffffffffffffff)
61        ) == ints2octs((2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255))
62
63    def testNegLong(self):
64        assert encoder.encode(
65            univ.Integer(-0xffffffffffffffff)
66        ) == ints2octs((2, 9, 255, 0, 0, 0, 0, 0, 0, 0, 1))
67
68
69class IntegerEncoderWithSchemaTestCase(BaseTestCase):
70    def testPosInt(self):
71        assert encoder.encode(12, asn1Spec=univ.Integer()) == ints2octs((2, 1, 12))
72
73    def testNegInt(self):
74        assert encoder.encode(-12, asn1Spec=univ.Integer()) == ints2octs((2, 1, 244))
75
76    def testZero(self):
77        assert encoder.encode(0, asn1Spec=univ.Integer()) == ints2octs((2, 1, 0))
78
79    def testPosLong(self):
80        assert encoder.encode(
81            0xffffffffffffffff, asn1Spec=univ.Integer()
82        ) == ints2octs((2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255))
83
84
85class BooleanEncoderTestCase(BaseTestCase):
86    def testTrue(self):
87        assert encoder.encode(univ.Boolean(1)) == ints2octs((1, 1, 1))
88
89    def testFalse(self):
90        assert encoder.encode(univ.Boolean(0)) == ints2octs((1, 1, 0))
91
92
93class BooleanEncoderWithSchemaTestCase(BaseTestCase):
94    def testTrue(self):
95        assert encoder.encode(True, asn1Spec=univ.Boolean()) == ints2octs((1, 1, 1))
96
97    def testFalse(self):
98        assert encoder.encode(False, asn1Spec=univ.Boolean()) == ints2octs((1, 1, 0))
99
100
101class BitStringEncoderTestCase(BaseTestCase):
102    def setUp(self):
103        BaseTestCase.setUp(self)
104        self.b = univ.BitString((1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1))
105
106    def testDefMode(self):
107        assert encoder.encode(self.b) == ints2octs((3, 3, 1, 169, 138))
108
109    def testIndefMode(self):
110        assert encoder.encode(
111            self.b, defMode=False
112        ) == ints2octs((3, 3, 1, 169, 138))
113
114    def testDefModeChunked(self):
115        assert encoder.encode(
116            self.b, maxChunkSize=1
117        ) == ints2octs((35, 8, 3, 2, 0, 169, 3, 2, 1, 138))
118
119    def testIndefModeChunked(self):
120        assert encoder.encode(
121            self.b, defMode=False, maxChunkSize=1
122        ) == ints2octs((35, 128, 3, 2, 0, 169, 3, 2, 1, 138, 0, 0))
123
124    def testEmptyValue(self):
125        assert encoder.encode(univ.BitString([])) == ints2octs((3, 1, 0))
126
127
128class BitStringEncoderWithSchemaTestCase(BaseTestCase):
129    def setUp(self):
130        BaseTestCase.setUp(self)
131        self.b = (1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1)
132        self.s = univ.BitString()
133
134    def testDefMode(self):
135        assert encoder.encode(self.b, asn1Spec=self.s) == ints2octs((3, 3, 1, 169, 138))
136
137    def testIndefMode(self):
138        assert encoder.encode(
139            self.b, asn1Spec=self.s, defMode=False
140        ) == ints2octs((3, 3, 1, 169, 138))
141
142    def testDefModeChunked(self):
143        assert encoder.encode(
144            self.b, asn1Spec=self.s, maxChunkSize=1
145        ) == ints2octs((35, 8, 3, 2, 0, 169, 3, 2, 1, 138))
146
147    def testIndefModeChunked(self):
148        assert encoder.encode(
149            self.b, asn1Spec=self.s, defMode=False, maxChunkSize=1
150        ) == ints2octs((35, 128, 3, 2, 0, 169, 3, 2, 1, 138, 0, 0))
151
152    def testEmptyValue(self):
153        assert encoder.encode([],  asn1Spec=self.s) == ints2octs((3, 1, 0))
154
155
156class OctetStringEncoderTestCase(BaseTestCase):
157    def setUp(self):
158        BaseTestCase.setUp(self)
159        self.o = univ.OctetString('Quick brown fox')
160
161    def testDefMode(self):
162        assert encoder.encode(self.o) == ints2octs(
163            (4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
164
165    def testIndefMode(self):
166        assert encoder.encode(
167            self.o, defMode=False
168        ) == ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
169
170    def testDefModeChunked(self):
171        assert encoder.encode(
172            self.o, maxChunkSize=4
173        ) == ints2octs((36, 23, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119,
174                        110, 32, 4, 3, 102, 111, 120))
175
176    def testIndefModeChunked(self):
177        assert encoder.encode(
178            self.o, defMode=False, maxChunkSize=4
179        ) == ints2octs((36, 128, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110,
180                        32, 4, 3, 102,  111, 120, 0, 0))
181
182
183class OctetStringEncoderWithSchemaTestCase(BaseTestCase):
184    def setUp(self):
185        BaseTestCase.setUp(self)
186        self.s = univ.OctetString()
187        self.o = 'Quick brown fox'
188
189    def testDefMode(self):
190        assert encoder.encode(self.o, asn1Spec=self.s) == ints2octs(
191            (4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
192
193    def testIndefMode(self):
194        assert encoder.encode(
195            self.o, asn1Spec=self.s, defMode=False
196        ) == ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
197
198    def testDefModeChunked(self):
199        assert encoder.encode(
200            self.o, asn1Spec=self.s, maxChunkSize=4
201        ) == ints2octs((36, 23, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119,
202                        110, 32, 4, 3, 102, 111, 120))
203
204    def testIndefModeChunked(self):
205        assert encoder.encode(
206            self.o, asn1Spec=self.s, defMode=False, maxChunkSize=4
207        ) == ints2octs((36, 128, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110,
208                        32, 4, 3, 102,  111, 120, 0, 0))
209
210
211class ExpTaggedOctetStringEncoderTestCase(BaseTestCase):
212    def setUp(self):
213        BaseTestCase.setUp(self)
214        self.o = univ.OctetString().subtype(
215            value='Quick brown fox',
216            explicitTag=tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 5)
217        )
218
219    def testDefMode(self):
220        assert encoder.encode(self.o) == ints2octs(
221            (101, 17, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
222
223    def testIndefMode(self):
224        assert encoder.encode(
225            self.o, defMode=False
226        ) == ints2octs((101, 128, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 0, 0))
227
228    def testDefModeChunked(self):
229        assert encoder.encode(
230            self.o, defMode=True, maxChunkSize=4
231        ) == ints2octs((101, 25, 36, 23, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3,
232                        102, 111, 120))
233
234    def testIndefModeChunked(self):
235        assert encoder.encode(
236            self.o, defMode=False, maxChunkSize=4
237        ) == ints2octs((101, 128, 36, 128, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120, 0, 0, 0, 0))
238
239
240class NullEncoderTestCase(BaseTestCase):
241    def testNull(self):
242        assert encoder.encode(univ.Null('')) == ints2octs((5, 0))
243
244
245class NullEncoderWithSchemaTestCase(BaseTestCase):
246    def testNull(self):
247        assert encoder.encode(None, univ.Null()) == ints2octs((5, 0))
248
249
250class ObjectIdentifierEncoderTestCase(BaseTestCase):
251    def testOne(self):
252        assert encoder.encode(
253            univ.ObjectIdentifier((1, 3, 6, 0, 0xffffe))
254        ) == ints2octs((6, 6, 43, 6, 0, 191, 255, 126))
255
256    def testEdge1(self):
257        assert encoder.encode(
258            univ.ObjectIdentifier((0, 39))
259        ) == ints2octs((6, 1, 39))
260
261    def testEdge2(self):
262        assert encoder.encode(
263            univ.ObjectIdentifier((1, 39))
264        ) == ints2octs((6, 1, 79))
265
266    def testEdge3(self):
267        # 01111111
268        assert encoder.encode(
269            univ.ObjectIdentifier((2, 40))
270        ) == ints2octs((6, 1, 120))
271
272    def testEdge4(self):
273        # 10010000|10000000|10000000|10000000|01001111
274        assert encoder.encode(
275            univ.ObjectIdentifier((2, 0xffffffff))
276        ) == ints2octs((6, 5, 0x90, 0x80, 0x80, 0x80, 0x4F))
277
278    def testEdge5(self):
279        # 01111111
280        assert encoder.encode(
281            univ.ObjectIdentifier((2, 47))
282        ) == ints2octs((6, 1, 0x7F))
283
284    def testEdge6(self):
285        # 10000001|00000000
286        assert encoder.encode(
287            univ.ObjectIdentifier((2, 48))
288        ) == ints2octs((6, 2, 0x81, 0x00))
289
290    def testEdge7(self):
291        # 10000001|00110100|00000003
292        assert encoder.encode(
293            univ.ObjectIdentifier((2, 100, 3))
294        ) == ints2octs((6, 3, 0x81, 0x34, 0x03))
295
296    def testEdge8(self):
297        # 10000101|00000000
298        assert encoder.encode(
299            univ.ObjectIdentifier((2, 560))
300        ) == ints2octs((6, 2, 133, 0))
301
302    def testEdge9(self):
303        # 10001000|10000100|10000111|0000010
304        assert encoder.encode(
305            univ.ObjectIdentifier((2, 16843570))
306        ) == ints2octs((6, 4, 0x88, 0x84, 0x87, 0x02))
307
308    def testEdgeA(self):
309        assert encoder.encode(
310            univ.ObjectIdentifier((2, 5))
311        ) == ints2octs((6, 1, 85))
312
313    def testImpossible1(self):
314        try:
315            encoder.encode(univ.ObjectIdentifier((3, 1, 2)))
316        except PyAsn1Error:
317            pass
318        else:
319            assert 0, 'impossible leading arc tolerated'
320
321    def testImpossible2(self):
322        try:
323            encoder.encode(univ.ObjectIdentifier((0,)))
324        except PyAsn1Error:
325            pass
326        else:
327            assert 0, 'single arc OID tolerated'
328
329    def testImpossible3(self):
330        try:
331            encoder.encode(univ.ObjectIdentifier((0, 40)))
332        except PyAsn1Error:
333            pass
334        else:
335            assert 0, 'second arc overflow tolerated'
336
337    def testImpossible4(self):
338        try:
339            encoder.encode(univ.ObjectIdentifier((1, 40)))
340        except PyAsn1Error:
341            pass
342        else:
343            assert 0, 'second arc overflow tolerated'
344
345    def testLarge1(self):
346        assert encoder.encode(
347            univ.ObjectIdentifier((2, 18446744073709551535184467440737095))
348        ) == ints2octs((0x06, 0x11, 0x83, 0xC6, 0xDF, 0xD4, 0xCC, 0xB3, 0xFF, 0xFF, 0xFE, 0xF0, 0xB8, 0xD6, 0xB8, 0xCB,
349                        0xE2, 0xB7, 0x17))
350
351    def testLarge2(self):
352        assert encoder.encode(
353            univ.ObjectIdentifier((2, 999, 18446744073709551535184467440737095))
354        ) == ints2octs((0x06, 0x13, 0x88, 0x37, 0x83, 0xC6, 0xDF, 0xD4, 0xCC, 0xB3, 0xFF, 0xFF, 0xFE, 0xF0, 0xB8, 0xD6,
355                        0xB8, 0xCB, 0xE2, 0xB6, 0x47))
356
357
358class ObjectIdentifierWithSchemaEncoderTestCase(BaseTestCase):
359    def testOne(self):
360        assert encoder.encode(
361            (1, 3, 6, 0, 0xffffe), asn1Spec=univ.ObjectIdentifier()
362        ) == ints2octs((6, 6, 43, 6, 0, 191, 255, 126))
363
364
365class RealEncoderTestCase(BaseTestCase):
366    def testChar(self):
367        assert encoder.encode(
368            univ.Real((123, 10, 11))
369        ) == ints2octs((9, 7, 3, 49, 50, 51, 69, 49, 49))
370
371    def testBin1(self):
372        assert encoder.encode(  # default binEncBase = 2
373            univ.Real((0.5, 2, 0))  # check encbase = 2 and exponent = -1
374        ) == ints2octs((9, 3, 128, 255, 1))
375
376    def testBin2(self):
377        r = univ.Real((3.25, 2, 0))
378        r.binEncBase = 8  # change binEncBase only for this instance of Real
379        assert encoder.encode(
380            r  # check encbase = 8
381        ) == ints2octs((9, 3, 148, 255, 13))
382
383    def testBin3(self):
384        # change binEncBase in the RealEncoder instance => for all further Real
385        binEncBase, encoder.typeMap[univ.Real.typeId].binEncBase = encoder.typeMap[univ.Real.typeId].binEncBase, 16
386        assert encoder.encode(
387            univ.Real((0.00390625, 2, 0))  # check encbase = 16
388        ) == ints2octs((9, 3, 160, 254, 1))
389        encoder.typeMap[univ.Real.typeId].binEncBase = binEncBase
390
391    def testBin4(self):
392        # choose binEncBase automatically for all further Real (testBin[4-7])
393        binEncBase, encoder.typeMap[univ.Real.typeId].binEncBase = encoder.typeMap[univ.Real.typeId].binEncBase, None
394        assert encoder.encode(
395            univ.Real((1, 2, 0))  # check exponent = 0
396        ) == ints2octs((9, 3, 128, 0, 1))
397        encoder.typeMap[univ.Real.typeId].binEncBase = binEncBase
398
399    def testBin5(self):
400        assert encoder.encode(
401            univ.Real((3, 2, -1020))  # case of 2 octs for exponent and
402            # negative exponent and abs(exponent) is
403            # all 1's and fills the whole octet(s)
404        ) == ints2octs((9, 4, 129, 252, 4, 3))
405
406    def testBin6(self):
407        assert encoder.encode(
408            univ.Real((1, 2, 262140))  # case of 3 octs for exponent and
409            # check that first 9 bits for exponent
410            # are not all 1's
411        ) == ints2octs((9, 5, 130, 3, 255, 252, 1))
412
413    def testBin7(self):
414        assert encoder.encode(
415            univ.Real((-1, 2, 76354972))  # case of >3 octs for exponent and
416            # mantissa < 0
417        ) == ints2octs((9, 7, 195, 4, 4, 141, 21, 156, 1))
418
419    def testPlusInf(self):
420        assert encoder.encode(univ.Real('inf')) == ints2octs((9, 1, 64))
421
422    def testMinusInf(self):
423        assert encoder.encode(univ.Real('-inf')) == ints2octs((9, 1, 65))
424
425    def testZero(self):
426        assert encoder.encode(univ.Real(0)) == ints2octs((9, 0))
427
428
429class RealEncoderWithSchemaTestCase(BaseTestCase):
430    def testChar(self):
431        assert encoder.encode(
432            (123, 10, 11), asn1Spec=univ.Real()
433        ) == ints2octs((9, 7, 3, 49, 50, 51, 69, 49, 49))
434
435
436if sys.version_info[0:2] > (2, 5):
437    class UniversalStringEncoderTestCase(BaseTestCase):
438        def testEncoding(self):
439            assert encoder.encode(char.UniversalString(sys.version_info[0] >= 3 and 'abc' or unicode('abc'))) == ints2octs(
440                (28, 12, 0, 0, 0, 97, 0, 0, 0, 98, 0, 0, 0, 99)), 'Incorrect encoding'
441
442
443    class UniversalStringEncoderWithSchemaTestCase(BaseTestCase):
444        def testEncoding(self):
445            assert encoder.encode(
446                sys.version_info[0] >= 3 and 'abc' or unicode('abc'), asn1Spec=char.UniversalString()
447            ) == ints2octs((28, 12, 0, 0, 0, 97, 0, 0, 0, 98, 0, 0, 0, 99)), 'Incorrect encoding'
448
449
450class BMPStringEncoderTestCase(BaseTestCase):
451    def testEncoding(self):
452        assert encoder.encode(char.BMPString(sys.version_info[0] >= 3 and 'abc' or unicode('abc'))) == ints2octs(
453            (30, 6, 0, 97, 0, 98, 0, 99)), 'Incorrect encoding'
454
455
456class BMPStringEncoderWithSchemaTestCase(BaseTestCase):
457    def testEncoding(self):
458        assert encoder.encode(
459            sys.version_info[0] >= 3 and 'abc' or unicode('abc'), asn1Spec=char.BMPString()
460        ) == ints2octs((30, 6, 0, 97, 0, 98, 0, 99)), 'Incorrect encoding'
461
462
463class UTF8StringEncoderTestCase(BaseTestCase):
464    def testEncoding(self):
465        assert encoder.encode(char.UTF8String(sys.version_info[0] >= 3 and 'abc' or unicode('abc'))) == ints2octs(
466            (12, 3, 97, 98, 99)), 'Incorrect encoding'
467
468
469class UTF8StringEncoderWithSchemaTestCase(BaseTestCase):
470    def testEncoding(self):
471        assert encoder.encode(
472            sys.version_info[0] >= 3 and 'abc' or unicode('abc'), asn1Spec=char.UTF8String()
473        ) == ints2octs((12, 3, 97, 98, 99)), 'Incorrect encoding'
474
475
476class SequenceOfEncoderTestCase(BaseTestCase):
477    def testEmpty(self):
478        s = univ.SequenceOf()
479        s.clear()
480        assert encoder.encode(s) == ints2octs((48, 0))
481
482    def testDefMode(self):
483        s = univ.SequenceOf()
484        s.setComponentByPosition(0, univ.OctetString('quick brown'))
485        assert encoder.encode(s) == ints2octs((48, 13, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
486
487    def testIndefMode(self):
488        s = univ.SequenceOf()
489        s.setComponentByPosition(0, univ.OctetString('quick brown'))
490        assert encoder.encode(
491            s, defMode=False
492        ) == ints2octs((48, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
493
494    def testDefModeChunked(self):
495        s = univ.SequenceOf()
496        s.setComponentByPosition(0, univ.OctetString('quick brown'))
497        assert encoder.encode(
498            s, defMode=True, maxChunkSize=4
499        ) == ints2octs((48, 19, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
500
501    def testIndefModeChunked(self):
502        s = univ.SequenceOf()
503        s.setComponentByPosition(0, univ.OctetString('quick brown'))
504        assert encoder.encode(
505            s, defMode=False, maxChunkSize=4
506        ) == ints2octs((48, 128, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
507
508
509class SequenceOfEncoderWithSchemaTestCase(BaseTestCase):
510    def setUp(self):
511        BaseTestCase.setUp(self)
512        self.s = univ.SequenceOf(componentType=univ.OctetString())
513        self.v = ['quick brown']
514
515    def testEmpty(self):
516        assert encoder.encode([], asn1Spec=self.s) == ints2octs((48, 0))
517
518    def testDefMode(self):
519        assert encoder.encode(
520            self.v, asn1Spec=self.s
521        ) == ints2octs((48, 13, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
522
523    def testIndefMode(self):
524        assert encoder.encode(
525            self.v, asn1Spec=self.s, defMode=False
526        ) == ints2octs((48, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
527
528    def testDefModeChunked(self):
529        assert encoder.encode(
530            self.v, asn1Spec=self.s, defMode=True, maxChunkSize=4
531        ) == ints2octs((48, 19, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
532
533    def testIndefModeChunked(self):
534        assert encoder.encode(
535            self.v, asn1Spec=self.s, defMode=False, maxChunkSize=4
536        ) == ints2octs((48, 128, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
537
538
539class SequenceOfEncoderWithComponentsSchemaTestCase(BaseTestCase):
540    def setUp(self):
541        BaseTestCase.setUp(self)
542        self.s = univ.SequenceOf(componentType=univ.OctetString())
543
544    def __init(self):
545        self.s.clear()
546        self.s.setComponentByPosition(0, 'quick brown')
547
548    def testDefMode(self):
549        self.__init()
550        assert encoder.encode(self.s) == ints2octs((48, 13, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
551
552    def testIndefMode(self):
553        self.__init()
554        assert encoder.encode(
555            self.s, defMode=False
556        ) == ints2octs((48, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
557
558    def testDefModeChunked(self):
559        self.__init()
560        assert encoder.encode(
561            self.s, defMode=True, maxChunkSize=4
562        ) == ints2octs((48, 19, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
563
564    def testIndefModeChunked(self):
565        self.__init()
566        assert encoder.encode(
567            self.s, defMode=False, maxChunkSize=4
568        ) == ints2octs((48, 128, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
569
570
571class SetOfEncoderTestCase(BaseTestCase):
572    def testEmpty(self):
573        s = univ.SetOf()
574        s.clear()
575        assert encoder.encode(s) == ints2octs((49, 0))
576
577    def testDefMode(self):
578        s = univ.SetOf()
579        s.setComponentByPosition(0, univ.OctetString('quick brown'))
580        assert encoder.encode(s) == ints2octs((49, 13, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
581
582    def testIndefMode(self):
583        s = univ.SetOf()
584        s.setComponentByPosition(0, univ.OctetString('quick brown'))
585        assert encoder.encode(
586            s, defMode=False
587        ) == ints2octs((49, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
588
589    def testDefModeChunked(self):
590        s = univ.SetOf()
591        s.setComponentByPosition(0, univ.OctetString('quick brown'))
592        assert encoder.encode(
593            s, defMode=True, maxChunkSize=4
594        ) == ints2octs((49, 19, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
595
596    def testIndefModeChunked(self):
597        s = univ.SetOf()
598        s.setComponentByPosition(0, univ.OctetString('quick brown'))
599        assert encoder.encode(
600            s, defMode=False, maxChunkSize=4
601        ) == ints2octs((49, 128, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
602
603
604class SetOfEncoderWithSchemaTestCase(BaseTestCase):
605    def setUp(self):
606        BaseTestCase.setUp(self)
607        self.s = univ.SetOf(componentType=univ.OctetString())
608        self.v = ['quick brown']
609
610    def testEmpty(self):
611        s = univ.SetOf()
612        assert encoder.encode([], asn1Spec=self.s) == ints2octs((49, 0))
613
614    def testDefMode(self):
615        assert encoder.encode(
616            self.v, asn1Spec=self.s
617        ) == ints2octs((49, 13, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
618
619    def testIndefMode(self):
620        assert encoder.encode(
621            self.v, asn1Spec=self.s, defMode=False
622        ) == ints2octs((49, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
623
624    def testDefModeChunked(self):
625        assert encoder.encode(
626            self.v, asn1Spec=self.s, defMode=True, maxChunkSize=4
627        ) == ints2octs((49, 19, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
628
629    def testIndefModeChunked(self):
630        assert encoder.encode(
631            self.v, asn1Spec=self.s, defMode=False, maxChunkSize=4
632        ) == ints2octs(
633            (49, 128, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
634
635
636class SetOfEncoderWithComponentsSchemaTestCase(BaseTestCase):
637    def setUp(self):
638        BaseTestCase.setUp(self)
639        self.s = univ.SetOf(componentType=univ.OctetString())
640
641    def __init(self):
642        self.s.clear()
643        self.s.setComponentByPosition(0, 'quick brown')
644
645    def testDefMode(self):
646        self.__init()
647        assert encoder.encode(self.s) == ints2octs((49, 13, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
648
649    def testIndefMode(self):
650        self.__init()
651        assert encoder.encode(
652            self.s, defMode=False
653        ) == ints2octs((49, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
654
655    def testDefModeChunked(self):
656        self.__init()
657        assert encoder.encode(
658            self.s, defMode=True, maxChunkSize=4
659        ) == ints2octs((49, 19, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
660
661    def testIndefModeChunked(self):
662        self.__init()
663        assert encoder.encode(
664            self.s, defMode=False, maxChunkSize=4
665        ) == ints2octs((49, 128, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
666
667
668class SequenceEncoderTestCase(BaseTestCase):
669    def setUp(self):
670        BaseTestCase.setUp(self)
671        self.s = univ.Sequence()
672        self.s.setComponentByPosition(0, univ.Null(''))
673        self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
674        self.s.setComponentByPosition(2, univ.Integer(1))
675
676    def testDefMode(self):
677        assert encoder.encode(self.s) == ints2octs((48, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
678
679    def testIndefMode(self):
680        assert encoder.encode(
681            self.s, defMode=False
682        ) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
683
684    def testDefModeChunked(self):
685        assert encoder.encode(
686            self.s, defMode=True, maxChunkSize=4
687        ) == ints2octs((48, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1))
688
689    def testIndefModeChunked(self):
690        assert encoder.encode(
691            self.s, defMode=False, maxChunkSize=4
692        ) == ints2octs((48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))
693
694
695class SequenceEncoderWithSchemaTestCase(BaseTestCase):
696    def setUp(self):
697        BaseTestCase.setUp(self)
698        self.s = univ.Sequence(
699            componentType=namedtype.NamedTypes(
700                namedtype.NamedType('place-holder', univ.Null()),
701                namedtype.OptionalNamedType('first-name', univ.OctetString()),
702                namedtype.DefaultedNamedType('age', univ.Integer(33)),
703            )
704        )
705        self.v = {
706            'place-holder': None,
707            'first-name': 'quick brown',
708            'age': 1
709        }
710
711    def testEmpty(self):
712        try:
713            assert encoder.encode({}, asn1Spec=self.s)
714
715        except PyAsn1Error:
716            pass
717
718        else:
719            assert False, 'empty bare sequence tolerated'
720
721    def testDefMode(self):
722        assert encoder.encode(
723            self.v, asn1Spec=self.s
724        ) == ints2octs((48, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
725
726    def testIndefMode(self):
727        assert encoder.encode(
728            self.v, asn1Spec=self.s, defMode=False
729        ) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
730
731    def testDefModeChunked(self):
732        assert encoder.encode(
733            self.v, asn1Spec=self.s, defMode=True, maxChunkSize=4
734        ) == ints2octs((48, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1))
735
736    def testIndefModeChunked(self):
737        assert encoder.encode(
738            self.v, asn1Spec=self.s, defMode=False, maxChunkSize=4
739        ) == ints2octs((48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))
740
741
742class SequenceEncoderWithUntaggedOpenTypesTestCase(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.Any(), openType=openType)
755            )
756        )
757
758    def testEncodeOpenTypeChoiceOne(self):
759        self.s.clear()
760
761        self.s[0] = 1
762        self.s[1] = univ.Integer(12)
763
764        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
765            (48, 5, 2, 1, 1, 49, 50)
766        )
767
768    def testEncodeOpenTypeChoiceTwo(self):
769        self.s.clear()
770
771        self.s[0] = 2
772        self.s[1] = univ.OctetString('quick brown')
773
774        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
775            (48, 14, 2, 1, 2, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110)
776        )
777
778    def testEncodeOpenTypeUnknownId(self):
779        self.s.clear()
780
781        self.s[0] = 2
782        self.s[1] = univ.ObjectIdentifier('1.3.6')
783
784        try:
785            encoder.encode(self.s, asn1Spec=self.s)
786
787        except PyAsn1Error:
788            assert False, 'incompatible open type tolerated'
789
790    def testEncodeOpenTypeIncompatibleType(self):
791        self.s.clear()
792
793        self.s[0] = 2
794        self.s[1] = univ.ObjectIdentifier('1.3.6')
795
796        try:
797            encoder.encode(self.s, asn1Spec=self.s)
798
799        except PyAsn1Error:
800            assert False, 'incompatible open type tolerated'
801
802
803class SequenceEncoderWithImplicitlyTaggedOpenTypesTestCase(BaseTestCase):
804    def setUp(self):
805        BaseTestCase.setUp(self)
806
807        openType = opentype.OpenType(
808            'id',
809            {1: univ.Integer(),
810             2: univ.OctetString()}
811        )
812        self.s = univ.Sequence(
813            componentType=namedtype.NamedTypes(
814                namedtype.NamedType('id', univ.Integer()),
815                namedtype.NamedType('blob', univ.Any().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3)), openType=openType)
816            )
817        )
818
819    def testEncodeOpenTypeChoiceOne(self):
820        self.s.clear()
821
822        self.s[0] = 1
823        self.s[1] = univ.Integer(12)
824
825        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
826            (48, 9, 2, 1, 1, 131, 4, 131, 2, 49, 50)
827        )
828
829
830class SequenceEncoderWithExplicitlyTaggedOpenTypesTestCase(BaseTestCase):
831    def setUp(self):
832        BaseTestCase.setUp(self)
833
834        openType = opentype.OpenType(
835            'id',
836            {1: univ.Integer(),
837             2: univ.OctetString()}
838        )
839        self.s = univ.Sequence(
840            componentType=namedtype.NamedTypes(
841                namedtype.NamedType('id', univ.Integer()),
842                namedtype.NamedType('blob', univ.Any().subtype(explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3)), openType=openType)
843            )
844        )
845
846    def testEncodeOpenTypeChoiceOne(self):
847        self.s.clear()
848
849        self.s[0] = 1
850        self.s[1] = univ.Integer(12)
851
852        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
853            (48, 9, 2, 1, 1, 163, 4, 163, 2, 49, 50)
854    )
855
856
857class SequenceEncoderWithUntaggedSetOfOpenTypesTestCase(BaseTestCase):
858    def setUp(self):
859        BaseTestCase.setUp(self)
860
861        openType = opentype.OpenType(
862            'id',
863            {1: univ.Integer(),
864             2: univ.OctetString()}
865        )
866        self.s = univ.Sequence(
867            componentType=namedtype.NamedTypes(
868                namedtype.NamedType('id', univ.Integer()),
869                namedtype.NamedType('blob', univ.SetOf(
870                    componentType=univ.Any()), openType=openType)
871            )
872        )
873
874    def testEncodeOpenTypeChoiceOne(self):
875        self.s.clear()
876
877        self.s[0] = 1
878        self.s[1].append(univ.Integer(12))
879
880        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
881            (48, 7, 2, 1, 1, 49, 2, 49, 50)
882        )
883
884    def testEncodeOpenTypeChoiceTwo(self):
885        self.s.clear()
886
887        self.s[0] = 2
888        self.s[1].append(univ.OctetString('quick brown'))
889
890        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
891            (48, 16, 2, 1, 2, 49, 11, 113, 117, 105, 99, 107, 32, 98, 114,
892             111, 119, 110)
893        )
894
895    def testEncodeOpenTypeUnknownId(self):
896        self.s.clear()
897
898        self.s[0] = 2
899        self.s[1].append(univ.ObjectIdentifier('1.3.6'))
900
901        try:
902            encoder.encode(self.s, asn1Spec=self.s)
903
904        except PyAsn1Error:
905            assert False, 'incompatible open type tolerated'
906
907    def testEncodeOpenTypeIncompatibleType(self):
908        self.s.clear()
909
910        self.s[0] = 2
911        self.s[1].append(univ.ObjectIdentifier('1.3.6'))
912
913        try:
914            encoder.encode(self.s, asn1Spec=self.s)
915
916        except PyAsn1Error:
917            assert False, 'incompatible open type tolerated'
918
919
920class SequenceEncoderWithImplicitlyTaggedSetOfOpenTypesTestCase(BaseTestCase):
921    def setUp(self):
922        BaseTestCase.setUp(self)
923
924        openType = opentype.OpenType(
925            'id',
926            {1: univ.Integer(),
927             2: univ.OctetString()}
928        )
929        self.s = univ.Sequence(
930            componentType=namedtype.NamedTypes(
931                namedtype.NamedType('id', univ.Integer()),
932                namedtype.NamedType('blob', univ.SetOf(
933                    componentType=univ.Any().subtype(
934                        implicitTag=tag.Tag(
935                            tag.tagClassContext, tag.tagFormatSimple, 3))),
936                    openType=openType)
937            )
938        )
939
940    def testEncodeOpenTypeChoiceOne(self):
941        self.s.clear()
942
943        self.s[0] = 1
944        self.s[1].append(univ.Integer(12))
945
946        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
947            (48, 11, 2, 1, 1, 49, 6, 131, 4, 131, 2, 49, 50)
948        )
949
950
951class SequenceEncoderWithExplicitlyTaggedSetOfOpenTypesTestCase(BaseTestCase):
952    def setUp(self):
953        BaseTestCase.setUp(self)
954
955        openType = opentype.OpenType(
956            'id',
957            {1: univ.Integer(),
958             2: univ.OctetString()}
959        )
960        self.s = univ.Sequence(
961            componentType=namedtype.NamedTypes(
962                namedtype.NamedType('id', univ.Integer()),
963                namedtype.NamedType('blob', univ.SetOf(
964                    componentType=univ.Any().subtype(
965                        explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3))),
966                    openType=openType)
967            )
968        )
969
970    def testEncodeOpenTypeChoiceOne(self):
971        self.s.clear()
972
973        self.s[0] = 1
974        self.s[1].append(univ.Integer(12))
975
976        assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
977            (48, 11, 2, 1, 1, 49, 6, 163, 4, 163, 2, 49, 50)
978        )
979
980
981class SequenceEncoderWithComponentsSchemaTestCase(BaseTestCase):
982    def setUp(self):
983        BaseTestCase.setUp(self)
984        self.s = univ.Sequence(
985            componentType=namedtype.NamedTypes(
986                namedtype.NamedType('place-holder', univ.Null()),
987                namedtype.OptionalNamedType('first-name', univ.OctetString()),
988                namedtype.DefaultedNamedType('age', univ.Integer(33)),
989            )
990        )
991
992    def __init(self):
993        self.s.clear()
994        self.s.setComponentByPosition(0, '')
995
996    def __initWithOptional(self):
997        self.s.clear()
998        self.s.setComponentByPosition(0, '')
999        self.s.setComponentByPosition(1, 'quick brown')
1000
1001    def __initWithDefaulted(self):
1002        self.s.clear()
1003        self.s.setComponentByPosition(0, '')
1004        self.s.setComponentByPosition(2, 1)
1005
1006    def __initWithOptionalAndDefaulted(self):
1007        self.s.clear()
1008        self.s.setComponentByPosition(0, univ.Null(''))
1009        self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
1010        self.s.setComponentByPosition(2, univ.Integer(1))
1011
1012    def testDefMode(self):
1013        self.__init()
1014        assert encoder.encode(self.s) == ints2octs((48, 2, 5, 0))
1015
1016    def testIndefMode(self):
1017        self.__init()
1018        assert encoder.encode(
1019            self.s, defMode=False
1020        ) == ints2octs((48, 128, 5, 0, 0, 0))
1021
1022    def testDefModeChunked(self):
1023        self.__init()
1024        assert encoder.encode(
1025            self.s, defMode=True, maxChunkSize=4
1026        ) == ints2octs((48, 2, 5, 0))
1027
1028    def testIndefModeChunked(self):
1029        self.__init()
1030        assert encoder.encode(
1031            self.s, defMode=False, maxChunkSize=4
1032        ) == ints2octs((48, 128, 5, 0, 0, 0))
1033
1034    def testWithOptionalDefMode(self):
1035        self.__initWithOptional()
1036        assert encoder.encode(self.s) == ints2octs(
1037            (48, 15, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
1038
1039    def testWithOptionalIndefMode(self):
1040        self.__initWithOptional()
1041        assert encoder.encode(
1042            self.s, defMode=False
1043        ) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
1044
1045    def testWithOptionalDefModeChunked(self):
1046        self.__initWithOptional()
1047        assert encoder.encode(
1048            self.s, defMode=True, maxChunkSize=4
1049        ) == ints2octs((48, 21, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
1050
1051    def testWithOptionalIndefModeChunked(self):
1052        self.__initWithOptional()
1053        assert encoder.encode(
1054            self.s, defMode=False, maxChunkSize=4
1055        ) == ints2octs(
1056            (48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
1057
1058    def testWithDefaultedDefMode(self):
1059        self.__initWithDefaulted()
1060        assert encoder.encode(self.s) == ints2octs((48, 5, 5, 0, 2, 1, 1))
1061
1062    def testWithDefaultedIndefMode(self):
1063        self.__initWithDefaulted()
1064        assert encoder.encode(
1065            self.s, defMode=False
1066        ) == ints2octs((48, 128, 5, 0, 2, 1, 1, 0, 0))
1067
1068    def testWithDefaultedDefModeChunked(self):
1069        self.__initWithDefaulted()
1070        assert encoder.encode(
1071            self.s, defMode=True, maxChunkSize=4
1072        ) == ints2octs((48, 5, 5, 0, 2, 1, 1))
1073
1074    def testWithDefaultedIndefModeChunked(self):
1075        self.__initWithDefaulted()
1076        assert encoder.encode(
1077            self.s, defMode=False, maxChunkSize=4
1078        ) == ints2octs((48, 128, 5, 0, 2, 1, 1, 0, 0))
1079
1080    def testWithOptionalAndDefaultedDefMode(self):
1081        self.__initWithOptionalAndDefaulted()
1082        assert encoder.encode(self.s) == ints2octs(
1083            (48, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
1084
1085    def testWithOptionalAndDefaultedIndefMode(self):
1086        self.__initWithOptionalAndDefaulted()
1087        assert encoder.encode(
1088            self.s, defMode=False
1089        ) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
1090
1091    def testWithOptionalAndDefaultedDefModeChunked(self):
1092        self.__initWithOptionalAndDefaulted()
1093        assert encoder.encode(
1094            self.s, defMode=True, maxChunkSize=4
1095        ) == ints2octs(
1096            (48, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1))
1097
1098    def testWithOptionalAndDefaultedIndefModeChunked(self):
1099        self.__initWithOptionalAndDefaulted()
1100        assert encoder.encode(
1101            self.s, defMode=False, maxChunkSize=4
1102        ) == ints2octs((48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0,
1103                        0, 2, 1, 1, 0, 0))
1104
1105
1106class ExpTaggedSequenceEncoderTestCase(BaseTestCase):
1107    def setUp(self):
1108        BaseTestCase.setUp(self)
1109        s = univ.Sequence(
1110            componentType=namedtype.NamedTypes(
1111                namedtype.NamedType('number', univ.Integer()),
1112            )
1113        )
1114
1115        s = s.subtype(
1116            explicitTag=tag.Tag(tag.tagClassApplication, tag.tagFormatConstructed, 5)
1117        )
1118
1119        s[0] = 12
1120
1121        self.s = s
1122
1123    def testDefMode(self):
1124        assert encoder.encode(self.s) == ints2octs((101, 5, 48, 3, 2, 1, 12))
1125
1126    def testIndefMode(self):
1127        assert encoder.encode(
1128            self.s, defMode=False
1129        ) == ints2octs((101, 128, 48, 128, 2, 1, 12, 0, 0, 0, 0))
1130
1131
1132class ExpTaggedSequenceComponentEncoderTestCase(BaseTestCase):
1133    def setUp(self):
1134        BaseTestCase.setUp(self)
1135        self.s = univ.Sequence(
1136            componentType=namedtype.NamedTypes(
1137                namedtype.NamedType('number', univ.Boolean().subtype(explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
1138            )
1139        )
1140
1141        self.s[0] = True
1142
1143    def testDefMode(self):
1144        assert encoder.encode(self.s) == ints2octs((48, 5, 160, 3, 1, 1, 1))
1145
1146    def testIndefMode(self):
1147        assert encoder.encode(
1148            self.s, defMode=False
1149        ) == ints2octs((48, 128, 160, 3, 1, 1, 1, 0, 0, 0, 0))
1150
1151
1152class SetEncoderTestCase(BaseTestCase):
1153    def setUp(self):
1154        BaseTestCase.setUp(self)
1155        self.s = univ.Set()
1156        self.s.setComponentByPosition(0, univ.Null(''))
1157        self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
1158        self.s.setComponentByPosition(2, univ.Integer(1))
1159
1160    def testDefMode(self):
1161        assert encoder.encode(self.s) == ints2octs((49, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
1162
1163    def testIndefMode(self):
1164        assert encoder.encode(
1165            self.s, defMode=False
1166        ) == ints2octs((49, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
1167
1168    def testDefModeChunked(self):
1169        assert encoder.encode(
1170            self.s, defMode=True, maxChunkSize=4
1171        ) == ints2octs((49, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1))
1172
1173    def testIndefModeChunked(self):
1174        assert encoder.encode(
1175            self.s, defMode=False, maxChunkSize=4
1176        ) == ints2octs((49, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))
1177
1178
1179class SetEncoderWithSchemaTestCase(BaseTestCase):
1180    def setUp(self):
1181        BaseTestCase.setUp(self)
1182        self.s = univ.Set(
1183            componentType=namedtype.NamedTypes(
1184                namedtype.NamedType('place-holder', univ.Null()),
1185                namedtype.OptionalNamedType('first-name', univ.OctetString()),
1186                namedtype.DefaultedNamedType('age', univ.Integer(33)),
1187            )
1188        )
1189        self.v = {
1190            'place-holder': None,
1191            'first-name': 'quick brown',
1192            'age': 1
1193        }
1194
1195    def testEmpty(self):
1196        try:
1197            assert encoder.encode({}, asn1Spec=self.s)
1198
1199        except PyAsn1Error:
1200            pass
1201
1202        else:
1203            assert False, 'empty bare SET tolerated'
1204
1205    def testDefMode(self):
1206        assert encoder.encode(
1207            self.v, asn1Spec=self.s
1208        ) == ints2octs((49, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
1209
1210    def testIndefMode(self):
1211        assert encoder.encode(
1212            self.v, asn1Spec=self.s, defMode=False
1213        ) == ints2octs((49, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
1214
1215    def testDefModeChunked(self):
1216        assert encoder.encode(
1217            self.v, asn1Spec=self.s, defMode=True, maxChunkSize=4
1218        ) == ints2octs((49, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1))
1219
1220    def testIndefModeChunked(self):
1221        assert encoder.encode(
1222            self.v, asn1Spec=self.s, defMode=False, maxChunkSize=4
1223        ) == ints2octs((49, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))
1224
1225
1226class SetEncoderWithComponentsSchemaTestCase(BaseTestCase):
1227    def setUp(self):
1228        BaseTestCase.setUp(self)
1229        self.s = univ.Set(
1230            componentType=namedtype.NamedTypes(
1231                namedtype.NamedType('place-holder', univ.Null()),
1232                namedtype.OptionalNamedType('first-name', univ.OctetString()),
1233                namedtype.DefaultedNamedType('age', univ.Integer(33)),
1234            )
1235        )
1236
1237    def __init(self):
1238        self.s.clear()
1239        self.s.setComponentByPosition(0, '')
1240
1241    def __initWithOptional(self):
1242        self.s.clear()
1243        self.s.setComponentByPosition(0, '')
1244        self.s.setComponentByPosition(1, 'quick brown')
1245
1246    def __initWithDefaulted(self):
1247        self.s.clear()
1248        self.s.setComponentByPosition(0, '')
1249        self.s.setComponentByPosition(2, 1)
1250
1251    def __initWithOptionalAndDefaulted(self):
1252        self.s.clear()
1253        self.s.setComponentByPosition(0, univ.Null(''))
1254        self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
1255        self.s.setComponentByPosition(2, univ.Integer(1))
1256
1257    def testDefMode(self):
1258        self.__init()
1259        assert encoder.encode(self.s) == ints2octs((49, 2, 5, 0))
1260
1261    def testIndefMode(self):
1262        self.__init()
1263        assert encoder.encode(
1264            self.s, defMode=False
1265        ) == ints2octs((49, 128, 5, 0, 0, 0))
1266
1267    def testDefModeChunked(self):
1268        self.__init()
1269        assert encoder.encode(
1270            self.s, defMode=True, maxChunkSize=4
1271        ) == ints2octs((49, 2, 5, 0))
1272
1273    def testIndefModeChunked(self):
1274        self.__init()
1275        assert encoder.encode(
1276            self.s, defMode=False, maxChunkSize=4
1277        ) == ints2octs((49, 128, 5, 0, 0, 0))
1278
1279    def testWithOptionalDefMode(self):
1280        self.__initWithOptional()
1281        assert encoder.encode(self.s) == ints2octs(
1282            (49, 15, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
1283
1284    def testWithOptionalIndefMode(self):
1285        self.__initWithOptional()
1286        assert encoder.encode(
1287            self.s, defMode=False
1288        ) == ints2octs((49, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
1289
1290    def testWithOptionalDefModeChunked(self):
1291        self.__initWithOptional()
1292        assert encoder.encode(
1293            self.s, defMode=True, maxChunkSize=4
1294        ) == ints2octs((49, 21, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
1295
1296    def testWithOptionalIndefModeChunked(self):
1297        self.__initWithOptional()
1298        assert encoder.encode(
1299            self.s, defMode=False, maxChunkSize=4
1300        ) == ints2octs(
1301            (49, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
1302
1303    def testWithDefaultedDefMode(self):
1304        self.__initWithDefaulted()
1305        assert encoder.encode(self.s) == ints2octs((49, 5, 5, 0, 2, 1, 1))
1306
1307    def testWithDefaultedIndefMode(self):
1308        self.__initWithDefaulted()
1309        assert encoder.encode(
1310            self.s, defMode=False
1311        ) == ints2octs((49, 128, 5, 0, 2, 1, 1, 0, 0))
1312
1313    def testWithDefaultedDefModeChunked(self):
1314        self.__initWithDefaulted()
1315        assert encoder.encode(
1316            self.s, defMode=True, maxChunkSize=4
1317        ) == ints2octs((49, 5, 5, 0, 2, 1, 1))
1318
1319    def testWithDefaultedIndefModeChunked(self):
1320        self.__initWithDefaulted()
1321        assert encoder.encode(
1322            self.s, defMode=False, maxChunkSize=4
1323        ) == ints2octs((49, 128, 5, 0, 2, 1, 1, 0, 0))
1324
1325    def testWithOptionalAndDefaultedDefMode(self):
1326        self.__initWithOptionalAndDefaulted()
1327        assert encoder.encode(self.s) == ints2octs(
1328            (49, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
1329
1330    def testWithOptionalAndDefaultedIndefMode(self):
1331        self.__initWithOptionalAndDefaulted()
1332        assert encoder.encode(
1333            self.s, defMode=False
1334        ) == ints2octs((49, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
1335
1336    def testWithOptionalAndDefaultedDefModeChunked(self):
1337        self.__initWithOptionalAndDefaulted()
1338        assert encoder.encode(
1339            self.s, defMode=True, maxChunkSize=4
1340        ) == ints2octs(
1341            (49, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1))
1342
1343    def testWithOptionalAndDefaultedIndefModeChunked(self):
1344        self.__initWithOptionalAndDefaulted()
1345        assert encoder.encode(
1346            self.s, defMode=False, maxChunkSize=4
1347        ) == ints2octs((49, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))
1348
1349
1350class ChoiceEncoderTestCase(BaseTestCase):
1351
1352    def testEmpty(self):
1353        s = univ.Choice()
1354        try:
1355            encoder.encode(s)
1356        except PyAsn1Error:
1357            pass
1358        else:
1359            assert 0, 'encoded unset choice'
1360
1361    def testDefModeOptionOne(self):
1362        s = univ.Choice()
1363        s.setComponentByPosition(0, univ.Null(''))
1364        assert encoder.encode(s) == ints2octs((5, 0))
1365
1366    def testDefModeOptionTwo(self):
1367        s = univ.Choice()
1368        s.setComponentByPosition(0, univ.OctetString('quick brown'))
1369        assert encoder.encode(s) == ints2octs((4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
1370
1371    def testIndefMode(self):
1372        s = univ.Choice()
1373        s.setComponentByPosition(0, univ.OctetString('quick brown'))
1374        assert encoder.encode(
1375            s, defMode=False
1376        ) == ints2octs((4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
1377
1378    def testDefModeChunked(self):
1379        s = univ.Choice()
1380        s.setComponentByPosition(0, univ.OctetString('quick brown'))
1381        assert encoder.encode(
1382            s, defMode=True, maxChunkSize=4
1383        ) == ints2octs((36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
1384
1385    def testIndefModeChunked(self):
1386        s = univ.Choice()
1387        s.setComponentByPosition(0, univ.OctetString('quick brown'))
1388        assert encoder.encode(
1389            s, defMode=False, maxChunkSize=4
1390        ) == ints2octs((36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0))
1391
1392
1393class ChoiceEncoderWithSchemaTestCase(BaseTestCase):
1394    def setUp(self):
1395        BaseTestCase.setUp(self)
1396        self.s = univ.Choice(
1397            componentType=namedtype.NamedTypes(
1398                namedtype.NamedType('place-holder', univ.Null('')),
1399                namedtype.NamedType('number', univ.Integer(0)),
1400                namedtype.NamedType('string', univ.OctetString())
1401            )
1402        )
1403        self.v = {
1404            'place-holder': None
1405        }
1406
1407    def testFilled(self):
1408        assert encoder.encode(
1409            self.v, asn1Spec=self.s
1410        ) == ints2octs((5, 0))
1411
1412
1413class ChoiceEncoderWithComponentsSchemaTestCase(BaseTestCase):
1414    def setUp(self):
1415        BaseTestCase.setUp(self)
1416        self.s = univ.Choice(
1417            componentType=namedtype.NamedTypes(
1418                namedtype.NamedType('place-holder', univ.Null('')),
1419                namedtype.NamedType('number', univ.Integer(0)),
1420                namedtype.NamedType('string', univ.OctetString())
1421            )
1422        )
1423
1424    def testEmpty(self):
1425        try:
1426            encoder.encode(self.s)
1427        except PyAsn1Error:
1428            pass
1429        else:
1430            assert 0, 'encoded unset choice'
1431
1432    def testFilled(self):
1433        self.s.setComponentByPosition(0, univ.Null(''))
1434        assert encoder.encode(self.s) == ints2octs((5, 0))
1435
1436    def testTagged(self):
1437        s = self.s.subtype(
1438            explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 4)
1439        )
1440        s.setComponentByPosition(0, univ.Null(''))
1441        assert encoder.encode(s) == ints2octs((164, 2, 5, 0))
1442
1443    def testUndefLength(self):
1444        self.s.setComponentByPosition(2, univ.OctetString('abcdefgh'))
1445        assert encoder.encode(self.s, defMode=False, maxChunkSize=3) == ints2octs(
1446            (36, 128, 4, 3, 97, 98, 99, 4, 3, 100, 101, 102, 4, 2, 103, 104, 0, 0))
1447
1448    def testTaggedUndefLength(self):
1449        s = self.s.subtype(
1450            explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 4)
1451        )
1452        s.setComponentByPosition(2, univ.OctetString('abcdefgh'))
1453        assert encoder.encode(s, defMode=False, maxChunkSize=3) == ints2octs(
1454            (164, 128, 36, 128, 4, 3, 97, 98, 99, 4, 3, 100, 101, 102, 4, 2, 103, 104, 0, 0, 0, 0))
1455
1456
1457class AnyEncoderTestCase(BaseTestCase):
1458    def setUp(self):
1459        BaseTestCase.setUp(self)
1460        self.s = univ.Any(encoder.encode(univ.OctetString('fox')))
1461
1462    def testUntagged(self):
1463        assert encoder.encode(self.s) == ints2octs((4, 3, 102, 111, 120))
1464
1465    def testTaggedEx(self):
1466        s = self.s.subtype(
1467            explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4)
1468        )
1469        assert encoder.encode(s) == ints2octs((164, 5, 4, 3, 102, 111, 120))
1470
1471    def testTaggedIm(self):
1472        s = self.s.subtype(
1473            implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4)
1474        )
1475        assert encoder.encode(s) == ints2octs((132, 5, 4, 3, 102, 111, 120))
1476
1477
1478class AnyEncoderWithSchemaTestCase(BaseTestCase):
1479    def setUp(self):
1480        BaseTestCase.setUp(self)
1481        self.s = univ.Any()
1482        self.v = encoder.encode(univ.OctetString('fox'))
1483
1484    def testUntagged(self):
1485        assert encoder.encode(self.v, asn1Spec=self.s) == ints2octs((4, 3, 102, 111, 120))
1486
1487    def testTaggedEx(self):
1488        s = self.s.subtype(
1489            explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4)
1490        )
1491        assert encoder.encode(self.v, asn1Spec=s) == ints2octs((164, 5, 4, 3, 102, 111, 120))
1492
1493    def testTaggedIm(self):
1494        s = self.s.subtype(
1495            implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4)
1496        )
1497        assert encoder.encode(self.v, asn1Spec=s) == ints2octs((132, 5, 4, 3, 102, 111, 120))
1498
1499
1500suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
1501
1502if __name__ == '__main__':
1503    unittest.TextTestRunner(verbosity=2).run(suite)
1504