1#
2# This file is part of pyasn1 software.
3#
4# Copyright (c) 2005-2017, Ilya Etingof <etingof@gmail.com>
5# License: http://pyasn1.sf.net/license.html
6#
7import sys
8import math
9
10try:
11    import unittest2 as unittest
12
13except ImportError:
14    import unittest
15
16from tests.base import BaseTestCase
17
18from pyasn1.type import univ, tag, constraint, namedtype, namedval, error
19from pyasn1.compat.octets import str2octs, ints2octs, octs2ints
20from pyasn1.error import PyAsn1Error
21
22
23class NoValueTestCase(BaseTestCase):
24    def testSingleton(self):
25        assert univ.NoValue() is univ.NoValue(), 'NoValue is not a singleton'
26
27    def testRepr(self):
28        try:
29            repr(univ.noValue)
30
31        except PyAsn1Error:
32            assert False, 'repr() on NoValue object fails'
33
34    def testIsInstance(self):
35        try:
36            assert isinstance(univ.noValue, univ.NoValue), 'isinstance() on NoValue() object fails'
37
38        except PyAsn1Error:
39            assert False, 'isinstance() on NoValue object fails'
40
41    def testStr(self):
42        try:
43            str(univ.noValue)
44
45        except PyAsn1Error:
46            pass
47
48        else:
49            assert False, 'str() works for NoValue object'
50
51    def testLen(self):
52        try:
53            len(univ.noValue)
54
55        except PyAsn1Error:
56            pass
57
58        else:
59            assert False, 'len() works for NoValue object'
60
61    def testCmp(self):
62        try:
63            univ.noValue == 1
64
65        except PyAsn1Error:
66            pass
67
68        else:
69            assert False, 'comparison works for NoValue object'
70
71    def testSubs(self):
72        try:
73            univ.noValue[0]
74
75        except PyAsn1Error:
76            pass
77
78        else:
79            assert False, '__getitem__() works for NoValue object'
80
81    def testKey(self):
82        try:
83            univ.noValue['key']
84
85        except PyAsn1Error:
86            pass
87
88        else:
89            assert False, '__getitem__() works for NoValue object'
90
91    def testKeyAssignment(self):
92        try:
93            univ.noValue['key'] = 123
94
95        except PyAsn1Error:
96            pass
97
98        else:
99            assert False, '__setitem__() works for NoValue object'
100
101    def testInt(self):
102        try:
103            int(univ.noValue)
104
105        except PyAsn1Error:
106            pass
107
108        else:
109            assert False, 'integer conversion works for NoValue object'
110
111    def testAdd(self):
112        try:
113            univ.noValue + univ.noValue
114
115        except PyAsn1Error:
116            pass
117
118        else:
119            assert False, 'addition works for NoValue object'
120
121    def testBitShift(self):
122        try:
123            univ.noValue << 1
124
125        except PyAsn1Error:
126            pass
127
128        else:
129            assert False, 'bitshift works for NoValue object'
130
131    def testBooleanEvaluation(self):
132        try:
133            if univ.noValue:
134                pass
135
136        except PyAsn1Error:
137            pass
138
139        else:
140            assert False, 'boolean evaluation works for NoValue object'
141
142    def testSizeOf(self):
143        try:
144            if hasattr(sys, 'getsizeof'):
145                sys.getsizeof(univ.noValue)
146
147        except PyAsn1Error:
148            assert False, 'sizeof failed for NoValue object'
149
150
151class IntegerTestCase(BaseTestCase):
152    def testStr(self):
153        assert str(univ.Integer(1)) in ('1', '1L'), 'str() fails'
154
155    def testRepr(self):
156        assert eval(repr(univ.Integer(123)), {'Integer': univ.Integer}) == univ.Integer(123), 'repr() fails'
157
158    def testAnd(self):
159        assert univ.Integer(1) & 0 == 0, '__and__() fails'
160
161    def testOr(self):
162        assert univ.Integer(1) | 0 == 1, '__or__() fails'
163
164    def testXor(self):
165        assert univ.Integer(1) ^ 0 == 1, '__xor__() fails'
166
167    def testRand(self):
168        assert 0 & univ.Integer(1) == 0, '__rand__() fails'
169
170    def testRor(self):
171        assert 0 | univ.Integer(1) == 1, '__ror__() fails'
172
173    def testRxor(self):
174        assert 0 ^ univ.Integer(1) == 1, '__rxor__() fails'
175
176    def testAdd(self):
177        assert univ.Integer(-4) + 6 == 2, '__add__() fails'
178
179    def testRadd(self):
180        assert 4 + univ.Integer(5) == 9, '__radd__() fails'
181
182    def testSub(self):
183        assert univ.Integer(3) - 6 == -3, '__sub__() fails'
184
185    def testRsub(self):
186        assert 6 - univ.Integer(3) == 3, '__rsub__() fails'
187
188    def testMul(self):
189        assert univ.Integer(3) * -3 == -9, '__mul__() fails'
190
191    def testRmul(self):
192        assert 2 * univ.Integer(3) == 6, '__rmul__() fails'
193
194    def testDivInt(self):
195        assert univ.Integer(4) / 2 == 2, '__div__() fails'
196
197    if sys.version_info[0] > 2:
198        def testDivFloat(self):
199            assert univ.Integer(3) / 2 == 1.5, '__div__() fails'
200
201        def testRdivFloat(self):
202            assert 3 / univ.Integer(2) == 1.5, '__rdiv__() fails'
203    else:
204        def testDivFloat(self):
205            assert univ.Integer(3) / 2 == 1, '__div__() fails'
206
207        def testRdivFloat(self):
208            assert 3 / univ.Integer(2) == 1, '__rdiv__() fails'
209
210    def testRdivInt(self):
211        assert 6 / univ.Integer(3) == 2, '__rdiv__() fails'
212
213    if sys.version_info[0] > 2:
214        def testTrueDiv(self):
215            assert univ.Integer(3) / univ.Integer(2) == 1.5, '__truediv__() fails'
216
217    def testFloorDiv(self):
218        assert univ.Integer(3) // univ.Integer(2) == 1, '__floordiv__() fails'
219
220    def testMod(self):
221        assert univ.Integer(3) % 2 == 1, '__mod__() fails'
222
223    def testRmod(self):
224        assert 4 % univ.Integer(3) == 1, '__rmod__() fails'
225
226    def testPow(self):
227        assert univ.Integer(3) ** 2 == 9, '__pow__() fails'
228
229    def testRpow(self):
230        assert 2 ** univ.Integer(2) == 4, '__rpow__() fails'
231
232    def testLshift(self):
233        assert univ.Integer(1) << 1 == 2, '<< fails'
234
235    def testRshift(self):
236        assert univ.Integer(2) >> 1 == 1, '>> fails'
237
238    def testInt(self):
239        assert int(univ.Integer(3)) == 3, '__int__() fails'
240
241    def testLong(self):
242        assert int(univ.Integer(8)) == 8, '__long__() fails'
243
244    def testFloat(self):
245        assert float(univ.Integer(4)) == 4.0, '__float__() fails'
246
247    def testPos(self):
248        assert +univ.Integer(1) == 1, '__pos__() fails'
249
250    def testNeg(self):
251        assert -univ.Integer(1) == -1, '__neg__() fails'
252
253    def testInvert(self):
254        assert ~univ.Integer(1) == -2, '__invert__() fails'
255
256    def testRound(self):
257        assert round(univ.Integer(1), 3) == 1.0, '__round__() fails'
258
259    def testFloor(self):
260        assert math.floor(univ.Integer(1)) == 1, '__floor__() fails'
261
262    def testCeil(self):
263        assert math.ceil(univ.Integer(1)) == 1, '__ceil__() fails'
264
265    if sys.version_info[0:2] > (2, 5):
266        def testTrunc(self):
267            assert math.trunc(univ.Integer(1)) == 1, '__trunc__() fails'
268
269    def testPrettyIn(self):
270        assert univ.Integer('3') == 3, 'prettyIn() fails'
271
272    def testTag(self):
273        assert univ.Integer().tagSet == tag.TagSet(
274            (),
275            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x02)
276        )
277
278    def testNamedVals(self):
279
280        class Integer(univ.Integer):
281            namedValues = univ.Integer.namedValues.clone(('asn1', 1))
282
283        assert Integer('asn1') == 1, 'named val fails'
284        assert str(Integer('asn1')) != 'asn1', 'named val __str__() fails'
285
286    def testSubtype(self):
287        assert univ.Integer().subtype(
288            value=1,
289            implicitTag=tag.Tag(tag.tagClassPrivate, tag.tagFormatSimple, 2),
290            subtypeSpec=constraint.SingleValueConstraint(1, 3)
291        ) == univ.Integer(
292            value=1,
293            tagSet=tag.TagSet(tag.Tag(tag.tagClassPrivate,
294                                      tag.tagFormatSimple, 2)),
295            subtypeSpec=constraint.ConstraintsIntersection(constraint.SingleValueConstraint(1, 3))
296        )
297
298
299class BooleanTestCase(BaseTestCase):
300    def testTruth(self):
301        assert univ.Boolean(True) and univ.Boolean(1), 'Truth initializer fails'
302
303    def testFalse(self):
304        assert not univ.Boolean(False) and not univ.Boolean(0), 'False initializer fails'
305
306    def testStr(self):
307        assert str(univ.Boolean(1)) in ('1', '1L'), 'str() fails'
308
309    def testRepr(self):
310        assert eval(repr(univ.Boolean(1)), {'Boolean': univ.Boolean}) == univ.Boolean(1), 'repr() fails'
311
312    def testTag(self):
313        assert univ.Boolean().tagSet == tag.TagSet(
314            (),
315            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x01)
316        )
317
318    def testConstraints(self):
319
320        class Boolean(univ.Boolean):
321            pass
322
323        try:
324            Boolean(2)
325        except error.ValueConstraintError:
326            pass
327        else:
328            assert 0, 'constraint fail'
329
330
331class BitStringTestCase(BaseTestCase):
332    def setUp(self):
333        BaseTestCase.setUp(self)
334
335        self.b = univ.BitString(
336            namedValues=namedval.NamedValues(('Active', 0), ('Urgent', 1))
337        )
338
339    def testBinDefault(self):
340
341        class BinDefault(univ.BitString):
342            defaultBinValue = '1010100110001010'
343
344        assert BinDefault() == univ.BitString(binValue='1010100110001010')
345
346    def testHexDefault(self):
347
348        class HexDefault(univ.BitString):
349            defaultHexValue = 'A98A'
350
351        assert HexDefault() == univ.BitString(hexValue='A98A')
352
353    def testSet(self):
354        assert self.b.clone('Active') == (1,)
355        assert self.b.clone('Urgent') == (0, 1)
356        assert self.b.clone('Urgent, Active') == (1, 1)
357        assert self.b.clone("'1010100110001010'B") == (1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0)
358        assert self.b.clone("'A98A'H") == (1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0)
359        assert self.b.clone(binValue='1010100110001010') == (1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0)
360        assert self.b.clone(hexValue='A98A') == (1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0)
361        assert self.b.clone('1010100110001010') == (1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0)
362        assert self.b.clone((1, 0, 1)) == (1, 0, 1)
363
364    def testStr(self):
365        assert str(self.b.clone('Urgent')) == '01'
366
367    def testRepr(self):
368        assert eval(repr(self.b.clone('Urgent,Active')), {'BitString': univ.BitString}) == self.b.clone(
369            'Urgent,Active'), 'repr() fails'
370
371    def testTag(self):
372        assert univ.BitString().tagSet == tag.TagSet(
373            (),
374            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x03)
375        )
376
377    def testLen(self):
378        assert len(self.b.clone("'A98A'H")) == 16
379
380    def testGetItem(self):
381        assert self.b.clone("'A98A'H")[0] == 1
382        assert self.b.clone("'A98A'H")[1] == 0
383        assert self.b.clone("'A98A'H")[2] == 1
384
385    if sys.version_info[:2] > (2, 4):
386        def testReverse(self):
387            assert list(reversed(univ.BitString([0, 0, 1]))) == list(univ.BitString([1, 0, 0]))
388
389    def testAsOctets(self):
390        assert self.b.clone(hexValue='A98A').asOctets() == ints2octs((0xa9, 0x8a)), 'testAsOctets() fails'
391
392    def testAsInts(self):
393        assert self.b.clone(hexValue='A98A').asNumbers() == (0xa9, 0x8a), 'testAsNumbers() fails'
394
395    def testMultipleOfEightPadding(self):
396        assert self.b.clone((1, 0, 1)).asNumbers() == (5,)
397
398    def testAsInteger(self):
399        assert self.b.clone('11000000011001').asInteger() == 12313
400        assert self.b.clone('1100110011011111').asInteger() == 52447
401
402    def testStaticDef(self):
403
404        class BitString(univ.BitString):
405            pass
406
407        assert BitString('11000000011001').asInteger() == 12313
408
409
410class OctetStringWithUnicodeMixIn(object):
411
412    initializer = ()
413    encoding = 'us-ascii'
414
415    def setUp(self):
416        self.pythonString = ints2octs(self.initializer).decode(self.encoding)
417        self.encodedPythonString = self.pythonString.encode(self.encoding)
418        self.numbersString = tuple(octs2ints(self.encodedPythonString))
419
420    def testInit(self):
421        assert univ.OctetString(self.encodedPythonString) == self.encodedPythonString, '__init__() fails'
422
423    def testInitFromAsn1(self):
424            assert univ.OctetString(univ.OctetString(self.encodedPythonString)) == self.encodedPythonString
425            assert univ.OctetString(univ.Integer(123)) == univ.OctetString('123')
426
427    def testSerialized(self):
428        if sys.version_info[0] < 3:
429            assert str(univ.OctetString(self.encodedPythonString, encoding=self.encoding)) == self.encodedPythonString, '__str__() fails'
430        else:
431            assert bytes(univ.OctetString(self.encodedPythonString, encoding=self.encoding)) == self.encodedPythonString, '__str__() fails'
432
433    def testPrintable(self):
434        if sys.version_info[0] < 3:
435            assert str(univ.OctetString(self.encodedPythonString, encoding=self.encoding)) == self.encodedPythonString, '__str__() fails'
436            assert unicode(univ.OctetString(self.pythonString, encoding=self.encoding)) == self.pythonString, 'unicode init fails'
437        else:
438            assert str(univ.OctetString(self.pythonString, encoding=self.encoding)) == self.pythonString, 'unicode init fails'
439
440    def testSeq(self):
441        assert univ.OctetString(self.encodedPythonString)[0] == self.encodedPythonString[0], '__getitem__() fails'
442
443    def testRepr(self):
444        assert eval(repr(univ.OctetString('abc')), {'OctetString': univ.OctetString}) == univ.OctetString('abc'), 'repr() fails'
445
446    def testAsOctets(self):
447        assert univ.OctetString(self.encodedPythonString).asOctets() == self.encodedPythonString, 'testAsOctets() fails'
448
449    def testAsInts(self):
450        assert univ.OctetString(self.encodedPythonString).asNumbers() == self.numbersString, 'testAsNumbers() fails'
451
452    def testAdd(self):
453        assert univ.OctetString(self.encodedPythonString) + self.encodedPythonString == self.encodedPythonString + self.encodedPythonString, '__add__() fails'
454
455    def testRadd(self):
456        assert self.encodedPythonString + univ.OctetString(self.encodedPythonString) == self.encodedPythonString + self.encodedPythonString, '__radd__() fails'
457
458    def testMul(self):
459        assert univ.OctetString(self.encodedPythonString) * 2 == self.encodedPythonString * 2, '__mul__() fails'
460
461    def testRmul(self):
462        assert 2 * univ.OctetString(self.encodedPythonString) == 2 * self.encodedPythonString, '__rmul__() fails'
463
464    def testContains(self):
465        s = univ.OctetString(self.encodedPythonString)
466        assert self.encodedPythonString in s
467        assert self.encodedPythonString * 2 not in s
468
469    if sys.version_info[:2] > (2, 4):
470       def testReverse(self):
471           assert list(reversed(univ.OctetString(self.encodedPythonString))) == list(reversed(self.encodedPythonString))
472
473
474class OctetStringWithAsciiTestCase(OctetStringWithUnicodeMixIn, BaseTestCase):
475    initializer = (97, 102)
476    encoding = 'us-ascii'
477
478
479class OctetStringWithUtf8TestCase(OctetStringWithUnicodeMixIn, BaseTestCase):
480    initializer = (208, 176, 208, 177, 208, 178)
481    encoding = 'utf-8'
482
483
484class OctetStringWithUtf16TestCase(OctetStringWithUnicodeMixIn, BaseTestCase):
485    initializer = (4, 48, 4, 49, 4, 50)
486    encoding = 'utf-16-be'
487
488
489if sys.version_info[0] > 2:
490
491    # Somehow comparison of UTF-32 encoded strings does not work in Py2
492
493    class OctetStringWithUtf32TestCase(OctetStringWithUnicodeMixIn, BaseTestCase):
494        initializer = (0, 0, 4, 48, 0, 0, 4, 49, 0, 0, 4, 50)
495        encoding = 'utf-32-be'
496
497
498class OctetStringTestCase(BaseTestCase):
499
500    def testBinDefault(self):
501
502        class BinDefault(univ.OctetString):
503            defaultBinValue = '1000010111101110101111000000111011'
504
505        assert BinDefault() == univ.OctetString(binValue='1000010111101110101111000000111011')
506
507    def testHexDefault(self):
508
509        class HexDefault(univ.OctetString):
510            defaultHexValue = 'FA9823C43E43510DE3422'
511
512        assert HexDefault() == univ.OctetString(hexValue='FA9823C43E43510DE3422')
513
514    def testBinStr(self):
515        assert univ.OctetString(binValue="1000010111101110101111000000111011") == ints2octs((133, 238, 188, 14, 192)), 'bin init fails'
516
517    def testHexStr(self):
518        assert univ.OctetString(hexValue="FA9823C43E43510DE3422") == ints2octs((250, 152, 35, 196, 62, 67, 81, 13, 227, 66, 32)), 'hex init fails'
519
520    def testTuple(self):
521        assert univ.OctetString((1, 2, 3, 4, 5)) == ints2octs((1, 2, 3, 4, 5)), 'tuple init failed'
522
523    def testRepr(self):
524        assert eval(repr(univ.OctetString('abc')), {'OctetString': univ.OctetString}) == univ.OctetString('abc'), 'repr() fails'
525
526    def testEmpty(self):
527        try:
528            str(univ.OctetString())
529        except PyAsn1Error:
530            pass
531        else:
532            assert 0, 'empty OctetString() not reported'
533
534    def testTag(self):
535        assert univ.OctetString().tagSet == tag.TagSet(
536            (),
537            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x04)
538        )
539
540    def testStaticDef(self):
541
542        class OctetString(univ.OctetString):
543            pass
544
545        assert OctetString(hexValue="FA9823C43E43510DE3422") == ints2octs((250, 152, 35, 196, 62, 67, 81, 13, 227, 66, 32))
546
547
548class Null(BaseTestCase):
549    def testStr(self):
550        assert str(univ.Null('')) == '', 'str() fails'
551
552    def testRepr(self):
553        assert eval(repr(univ.Null()), {'Null': univ.Null}) == univ.Null(), 'repr() fails'
554
555    def testTag(self):
556        assert univ.Null().tagSet == tag.TagSet(
557            (),
558            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x05)
559        )
560
561    def testConstraints(self):
562        try:
563            univ.Null(2)
564        except error.ValueConstraintError:
565            pass
566        else:
567            assert 0, 'constraint fail'
568
569    def testStaticDef(self):
570
571        class Null(univ.Null):
572            pass
573
574        assert not Null()
575
576
577class RealTestCase(BaseTestCase):
578    def testFloat4BinEnc(self):
579        assert univ.Real((0.25, 2, 3)) == 2.0, 'float initializer for binary encoding fails'
580
581    def testStr(self):
582        assert str(univ.Real(1.0)) == '1.0', 'str() fails'
583
584    def testRepr(self):
585        assert eval(repr(univ.Real(-4.1)), {'Real': univ.Real}) == univ.Real(-4.1), 'repr() fails'
586        assert repr(univ.Real(-4.1)) == 'Real((-41, 10, -1))', 'repr() fails'
587        assert eval(repr(univ.Real('inf')), {'Real': univ.Real}) == univ.Real('inf'), 'repr() fails'
588        assert repr(univ.Real('inf')) == 'Real(\'inf\')', 'repr() fails'
589
590    def testAdd(self):
591        assert univ.Real(-4.1) + 1.4 == -2.7, '__add__() fails'
592
593    def testRadd(self):
594        assert 4 + univ.Real(0.5) == 4.5, '__radd__() fails'
595
596    def testSub(self):
597        assert univ.Real(3.9) - 1.7 == 2.2, '__sub__() fails'
598
599    def testRsub(self):
600        assert 6.1 - univ.Real(0.1) == 6, '__rsub__() fails'
601
602    def testMul(self):
603        assert univ.Real(3.0) * -3 == -9, '__mul__() fails'
604
605    def testRmul(self):
606        assert 2 * univ.Real(3.0) == 6, '__rmul__() fails'
607
608    def testDiv(self):
609        assert univ.Real(3.0) / 2 == 1.5, '__div__() fails'
610
611    def testRdiv(self):
612        assert 6 / univ.Real(3.0) == 2, '__rdiv__() fails'
613
614    def testMod(self):
615        assert univ.Real(3.0) % 2 == 1, '__mod__() fails'
616
617    def testRmod(self):
618        assert 4 % univ.Real(3.0) == 1, '__rmod__() fails'
619
620    def testPow(self):
621        assert univ.Real(3.0) ** 2 == 9, '__pow__() fails'
622
623    def testRpow(self):
624        assert 2 ** univ.Real(2.0) == 4, '__rpow__() fails'
625
626    def testInt(self):
627        assert int(univ.Real(3.0)) == 3, '__int__() fails'
628
629    def testLong(self):
630        assert int(univ.Real(8.0)) == 8, '__long__() fails'
631
632    def testFloat(self):
633        assert float(univ.Real(4.0)) == 4.0, '__float__() fails'
634
635    def testPrettyIn(self):
636        assert univ.Real((3, 10, 0)) == 3, 'prettyIn() fails'
637
638    # infinite float values
639    def testStrInf(self):
640        assert str(univ.Real('inf')) == 'inf', 'str() fails'
641
642    def testAddInf(self):
643        assert univ.Real('inf') + 1 == float('inf'), '__add__() fails'
644
645    def testRaddInf(self):
646        assert 1 + univ.Real('inf') == float('inf'), '__radd__() fails'
647
648    def testIntInf(self):
649        try:
650            assert int(univ.Real('inf'))
651        except OverflowError:
652            pass
653        else:
654            assert 0, '__int__() fails'
655
656    def testLongInf(self):
657        try:
658            assert int(univ.Real('inf'))
659        except OverflowError:
660            pass
661        else:
662            assert 0, '__long__() fails'
663        assert int(univ.Real(8.0)) == 8, '__long__() fails'
664
665    def testFloatInf(self):
666        assert float(univ.Real('-inf')) == float('-inf'), '__float__() fails'
667
668    def testPrettyInInf(self):
669        assert univ.Real(float('inf')) == float('inf'), 'prettyIn() fails'
670
671    def testPlusInf(self):
672        assert univ.Real('inf').isPlusInf, 'isPlusInfinity failed'
673
674    def testMinusInf(self):
675        assert univ.Real('-inf').isMinusInf, 'isMinusInfinity failed'
676
677    def testPos(self):
678        assert +univ.Real(1.0) == 1.0, '__pos__() fails'
679
680    def testNeg(self):
681        assert -univ.Real(1.0) == -1.0, '__neg__() fails'
682
683    def testRound(self):
684        assert round(univ.Real(1.123), 2) == 1.12, '__round__() fails'
685
686    def testFloor(self):
687        assert math.floor(univ.Real(1.6)) == 1.0, '__floor__() fails'
688
689    def testCeil(self):
690        assert math.ceil(univ.Real(1.2)) == 2.0, '__ceil__() fails'
691
692    if sys.version_info[0:2] > (2, 5):
693        def testTrunc(self):
694            assert math.trunc(univ.Real(1.1)) == 1.0, '__trunc__() fails'
695
696    def testTag(self):
697        assert univ.Real().tagSet == tag.TagSet(
698            (),
699            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x09)
700        )
701
702    def testStaticDef(self):
703
704        class Real(univ.Real):
705            pass
706
707        assert Real(1.0) == 1.0
708
709
710class ObjectIdentifier(BaseTestCase):
711    def testStr(self):
712        assert str(univ.ObjectIdentifier((1, 3, 6))) == '1.3.6', 'str() fails'
713
714    def testRepr(self):
715        assert eval(repr(univ.ObjectIdentifier('1.3.6')),
716                    {'ObjectIdentifier': univ.ObjectIdentifier}) == univ.ObjectIdentifier('1.3.6'), 'repr() fails'
717
718    def testEq(self):
719        assert univ.ObjectIdentifier((1, 3, 6)) == (1, 3, 6), '__cmp__() fails'
720
721    def testAdd(self):
722        assert univ.ObjectIdentifier((1, 3)) + (6,) == (1, 3, 6), '__add__() fails'
723
724    def testRadd(self):
725        assert (1,) + univ.ObjectIdentifier((3, 6)) == (1, 3, 6), '__radd__() fails'
726
727    def testLen(self):
728        assert len(univ.ObjectIdentifier((1, 3))) == 2, '__len__() fails'
729
730    def testPrefix(self):
731        o = univ.ObjectIdentifier('1.3.6')
732        assert o.isPrefixOf((1, 3, 6)), 'isPrefixOf() fails'
733        assert o.isPrefixOf((1, 3, 6, 1)), 'isPrefixOf() fails'
734        assert not o.isPrefixOf((1, 3)), 'isPrefixOf() fails'
735
736    def testInput1(self):
737        assert univ.ObjectIdentifier('1.3.6') == (1, 3, 6), 'prettyIn() fails'
738
739    def testInput2(self):
740        assert univ.ObjectIdentifier((1, 3, 6)) == (1, 3, 6), 'prettyIn() fails'
741
742    def testInput3(self):
743        assert univ.ObjectIdentifier(univ.ObjectIdentifier('1.3') + (6,)) == (1, 3, 6), 'prettyIn() fails'
744
745    def testUnicode(self):
746        s = '1.3.6'
747        if sys.version_info[0] < 3:
748            s = s.decode()
749        assert univ.ObjectIdentifier(s) == (1, 3, 6), 'unicode init fails'
750
751    def testTag(self):
752        assert univ.ObjectIdentifier().tagSet == tag.TagSet(
753            (),
754            tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x06)
755        )
756
757    def testContains(self):
758        s = univ.ObjectIdentifier('1.3.6.1234.99999')
759        assert 1234 in s
760        assert 4321 not in s
761
762    def testStaticDef(self):
763
764        class ObjectIdentifier(univ.ObjectIdentifier):
765            pass
766
767        assert str(ObjectIdentifier((1, 3, 6))) == '1.3.6'
768
769
770class SequenceOf(BaseTestCase):
771    def setUp(self):
772        BaseTestCase.setUp(self)
773        self.s1 = univ.SequenceOf(
774            componentType=univ.OctetString('')
775        )
776        self.s2 = self.s1.clone()
777
778    def testRepr(self):
779        assert eval(repr(self.s1.clone().setComponents('a', 'b')),
780                    {'SequenceOf': univ.SequenceOf,
781                     'OctetString': univ.OctetString}) == self.s1.clone().setComponents(
782            'a', 'b'), 'repr() fails'
783
784    def testTag(self):
785        assert self.s1.tagSet == tag.TagSet(
786            (),
787            tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x10)
788        ), 'wrong tagSet'
789
790    def testSeq(self):
791        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
792        assert self.s1[0] == str2octs('abc'), 'set by idx fails'
793        self.s1[0] = 'cba'
794        assert self.s1[0] == str2octs('cba'), 'set by idx fails'
795
796    def testCmp(self):
797        self.s1.clear()
798        self.s1.setComponentByPosition(0, 'abc')
799        self.s2.clear()
800        self.s2.setComponentByPosition(0, univ.OctetString('abc'))
801        assert self.s1 == self.s2, '__cmp__() fails'
802
803    def testSubtypeSpec(self):
804        s = self.s1.clone(subtypeSpec=constraint.ConstraintsUnion(
805            constraint.SingleValueConstraint(str2octs('abc'))
806        ))
807        try:
808            s.setComponentByPosition(0, univ.OctetString('abc'))
809        except PyAsn1Error:
810            assert 0, 'constraint fails'
811        try:
812            s.setComponentByPosition(1, univ.OctetString('Abc'))
813        except PyAsn1Error:
814            try:
815                s.setComponentByPosition(1, univ.OctetString('Abc'),
816                                         verifyConstraints=False)
817            except PyAsn1Error:
818                assert 0, 'constraint failes with verifyConstraints=True'
819        else:
820            assert 0, 'constraint fails'
821
822    def testComponentTagsMatching(self):
823        s = self.s1.clone()
824        s.strictConstraints = True  # This requires types equality
825        o = univ.OctetString('abc').subtype(explicitTag=tag.Tag(tag.tagClassPrivate, tag.tagFormatSimple, 12))
826        try:
827            s.setComponentByPosition(0, o)
828        except PyAsn1Error:
829            pass
830        else:
831            assert 0, 'inner supertype tag allowed'
832
833    def testComponentConstraintsMatching(self):
834        s = self.s1.clone()
835        o = univ.OctetString().subtype(
836            subtypeSpec=constraint.ConstraintsUnion(constraint.SingleValueConstraint(str2octs('cba'))))
837        s.strictConstraints = True  # This requires types equality
838        try:
839            s.setComponentByPosition(0, o.clone('cba'))
840        except PyAsn1Error:
841            pass
842        else:
843            assert 0, 'inner supertype constraint allowed'
844        s.strictConstraints = False  # This requires subtype relationships
845        try:
846            s.setComponentByPosition(0, o.clone('cba'))
847        except PyAsn1Error:
848            assert 0, 'inner supertype constraint disallowed'
849        else:
850            pass
851
852    def testSizeSpec(self):
853        s = self.s1.clone(sizeSpec=constraint.ConstraintsUnion(
854            constraint.ValueSizeConstraint(1, 1)
855        ))
856        s.setComponentByPosition(0, univ.OctetString('abc'))
857        try:
858            s.verifySizeSpec()
859        except PyAsn1Error:
860            assert 0, 'size spec fails'
861        s.setComponentByPosition(1, univ.OctetString('abc'))
862        try:
863            s.verifySizeSpec()
864        except PyAsn1Error:
865            pass
866        else:
867            assert 0, 'size spec fails'
868
869    def testGetComponentTagMap(self):
870        assert self.s1.componentType.tagMap.presentTypes == {
871            univ.OctetString.tagSet: univ.OctetString('')
872        }
873
874    def testSubtype(self):
875        self.s1.clear()
876        assert self.s1.subtype(
877            implicitTag=tag.Tag(tag.tagClassPrivate, tag.tagFormatSimple, 2),
878            subtypeSpec=constraint.SingleValueConstraint(1, 3),
879            sizeSpec=constraint.ValueSizeConstraint(0, 1)
880        ) == self.s1.clone(
881            tagSet=tag.TagSet(tag.Tag(tag.tagClassPrivate,
882                                      tag.tagFormatSimple, 2)),
883            subtypeSpec=constraint.ConstraintsIntersection(constraint.SingleValueConstraint(1, 3)),
884            sizeSpec=constraint.ValueSizeConstraint(0, 1)
885        )
886
887    def testClone(self):
888        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
889        s = self.s1.clone()
890        assert len(s) == 0
891        s = self.s1.clone(cloneValueFlag=1)
892        assert len(s) == 1
893        assert s.getComponentByPosition(0) == self.s1.getComponentByPosition(0)
894
895    def testSetComponents(self):
896        assert self.s1.clone().setComponents('abc', 'def') == \
897               self.s1.setComponentByPosition(0, 'abc').setComponentByPosition(1, 'def')
898
899    def testGetItem(self):
900        s = self.s1.clone()
901        s.append('xxx')
902        assert s[0]
903
904        try:
905            s[2]
906
907        except IndexError:
908            pass
909
910        else:
911            assert False, 'IndexError not raised'
912
913        # this is a deviation from standart sequence protocol
914        assert not s[1]
915
916    def testSetItem(self):
917        s = self.s1.clone()
918        s.append('xxx')
919
920        try:
921
922            s[2] = 'xxx'
923
924        except IndexError:
925            pass
926
927        else:
928            assert False, 'IndexError not raised'
929
930    def testAppend(self):
931        self.s1.clear()
932        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
933        assert len(self.s1) == 1
934        self.s1.append('def')
935        assert len(self.s1) == 2
936        assert list(self.s1) == [str2octs(x) for x in ['abc', 'def']]
937
938    def testExtend(self):
939        self.s1.clear()
940        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
941        assert len(self.s1) == 1
942        self.s1.extend(['def', 'ghi'])
943        assert len(self.s1) == 3
944        assert list(self.s1) == [str2octs(x) for x in ['abc', 'def', 'ghi']]
945
946    def testCount(self):
947        self.s1.clear()
948        for x in ['abc', 'def', 'abc']:
949            self.s1.append(x)
950        assert self.s1.count(str2octs('abc')) == 2
951        assert self.s1.count(str2octs('def')) == 1
952        assert self.s1.count(str2octs('ghi')) == 0
953
954    def testIndex(self):
955        self.s1.clear()
956        for x in ['abc', 'def', 'abc']:
957            self.s1.append(x)
958        assert self.s1.index(str2octs('abc')) == 0
959        assert self.s1.index(str2octs('def')) == 1
960        assert self.s1.index(str2octs('abc'), 1) == 2
961
962    def testSort(self):
963        self.s1.clear()
964        self.s1[0] = 'b'
965        self.s1[1] = 'a'
966        assert list(self.s1) == [str2octs('b'), str2octs('a')]
967        self.s1.sort()
968        assert list(self.s1) == [str2octs('a'), str2octs('b')]
969
970    def testStaticDef(self):
971
972        class SequenceOf(univ.SequenceOf):
973            componentType = univ.OctetString('')
974
975        s = SequenceOf()
976        s[0] = 'abc'
977        assert len(s) == 1
978        assert s == [str2octs('abc')]
979
980    def testLegacyInitializer(self):
981        n = univ.SequenceOf(
982            componentType=univ.OctetString()
983        )
984        o = univ.SequenceOf(
985            univ.OctetString()  # this is the old way
986        )
987
988        assert n.isSameTypeWith(o) and o.isSameTypeWith(n)
989
990        n[0] = 'fox'
991        o[0] = 'fox'
992
993        assert n == o
994
995class Sequence(BaseTestCase):
996    def setUp(self):
997        BaseTestCase.setUp(self)
998        self.s1 = univ.Sequence(
999            componentType=namedtype.NamedTypes(
1000                namedtype.NamedType('name', univ.OctetString('')),
1001                namedtype.OptionalNamedType('nick', univ.OctetString('')),
1002                namedtype.DefaultedNamedType('age', univ.Integer(34))
1003            )
1004        )
1005
1006    def testRepr(self):
1007        assert eval(
1008            repr(self.s1.clone().setComponents('a', 'b')),
1009            {'Sequence': univ.Sequence,
1010             'OctetString': univ.OctetString,
1011             'Integer': univ.Integer,
1012             'NamedTypes': namedtype.NamedTypes,
1013             'NamedType': namedtype.NamedType,
1014             'OptionalNamedType': namedtype.OptionalNamedType,
1015             'DefaultedNamedType': namedtype.DefaultedNamedType}
1016        ) == self.s1.clone().setComponents('a', 'b'), 'repr() fails'
1017
1018    def testTag(self):
1019        assert self.s1.tagSet == tag.TagSet(
1020            (),
1021            tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x10)
1022        ), 'wrong tagSet'
1023
1024    def testById(self):
1025        self.s1.setComponentByName('name', univ.OctetString('abc'))
1026        assert self.s1.getComponentByName('name') == str2octs('abc'), 'set by name fails'
1027
1028    def testByKey(self):
1029        self.s1['name'] = 'abc'
1030        assert self.s1['name'] == str2octs('abc'), 'set by key fails'
1031
1032    def testContains(self):
1033        assert 'name' in self.s1
1034        assert '<missing>' not in self.s1
1035
1036    def testGetNearPosition(self):
1037        assert self.s1.componentType.getTagMapNearPosition(1).presentTypes == {
1038            univ.OctetString.tagSet: univ.OctetString(''),
1039            univ.Integer.tagSet: univ.Integer(34)
1040        }
1041        assert self.s1.componentType.getPositionNearType(
1042            univ.OctetString.tagSet, 1
1043        ) == 1
1044
1045    def testSetDefaultComponents(self):
1046        self.s1.clear()
1047        self.s1.setComponentByPosition(0, univ.OctetString('Ping'))
1048        self.s1.setComponentByPosition(1, univ.OctetString('Pong'))
1049        assert self.s1.getComponentByPosition(2) == 34
1050
1051    def testClone(self):
1052        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
1053        self.s1.setComponentByPosition(1, univ.OctetString('def'))
1054        self.s1.setComponentByPosition(2, univ.Integer(123))
1055        s = self.s1.clone()
1056        assert s.getComponentByPosition(0) != self.s1.getComponentByPosition(0)
1057        assert s.getComponentByPosition(1) != self.s1.getComponentByPosition(1)
1058        assert s.getComponentByPosition(2) != self.s1.getComponentByPosition(2)
1059        s = self.s1.clone(cloneValueFlag=1)
1060        assert s.getComponentByPosition(0) == self.s1.getComponentByPosition(0)
1061        assert s.getComponentByPosition(1) == self.s1.getComponentByPosition(1)
1062        assert s.getComponentByPosition(2) == self.s1.getComponentByPosition(2)
1063
1064    def testComponentTagsMatching(self):
1065        s = self.s1.clone()
1066        s.strictConstraints = True  # This requires types equality
1067        o = univ.OctetString('abc').subtype(explicitTag=tag.Tag(tag.tagClassPrivate, tag.tagFormatSimple, 12))
1068        try:
1069            s.setComponentByName('name', o)
1070        except PyAsn1Error:
1071            pass
1072        else:
1073            assert 0, 'inner supertype tag allowed'
1074
1075    def testComponentConstraintsMatching(self):
1076        s = self.s1.clone()
1077        o = univ.OctetString().subtype(
1078            subtypeSpec=constraint.ConstraintsUnion(constraint.SingleValueConstraint(str2octs('cba'))))
1079        s.strictConstraints = True  # This requires types equality
1080        try:
1081            s.setComponentByName('name', o.clone('cba'))
1082        except PyAsn1Error:
1083            pass
1084        else:
1085            assert 0, 'inner supertype constraint allowed'
1086        s.strictConstraints = False  # This requires subtype relationships
1087        try:
1088            s.setComponentByName('name', o.clone('cba'))
1089        except PyAsn1Error:
1090            assert 0, 'inner supertype constraint disallowed'
1091        else:
1092            pass
1093
1094    def testSetComponents(self):
1095        assert self.s1.clone().setComponents(name='a', nick='b', age=1) == \
1096               self.s1.setComponentByPosition(0, 'a').setComponentByPosition(1, 'b').setComponentByPosition(2, 1)
1097
1098    def testSetToDefault(self):
1099        s = self.s1.clone()
1100        s.setComponentByPosition(0, univ.noValue)
1101        s[2] = univ.noValue
1102        assert s[0] == univ.OctetString('')
1103        assert s[2] == univ.Integer(34)
1104
1105    def testGetItem(self):
1106        s = self.s1.clone()
1107        s['name'] = 'xxx'
1108        assert s['name']
1109        assert s[0]
1110
1111        try:
1112            s['xxx']
1113
1114        except KeyError:
1115            pass
1116
1117        else:
1118            assert False, 'KeyError not raised'
1119
1120        try:
1121            s[100]
1122
1123        except IndexError:
1124            pass
1125
1126        else:
1127            assert False, 'IndexError not raised'
1128
1129    def testSetItem(self):
1130        s = self.s1.clone()
1131        s['name'] = 'xxx'
1132
1133        try:
1134
1135            s['xxx'] = 'xxx'
1136
1137        except KeyError:
1138            pass
1139
1140        else:
1141            assert False, 'KeyError not raised'
1142
1143        try:
1144
1145            s[100] = 'xxx'
1146
1147        except IndexError:
1148            pass
1149
1150        else:
1151            assert False, 'IndexError not raised'
1152
1153    def testIter(self):
1154        assert list(self.s1) == ['name', 'nick', 'age']
1155
1156    def testKeys(self):
1157        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
1158        self.s1.setComponentByPosition(1, univ.OctetString('def'))
1159        self.s1.setComponentByPosition(2, univ.Integer(123))
1160        assert list(self.s1.keys()) == ['name', 'nick', 'age']
1161
1162    def testValues(self):
1163        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
1164        self.s1.setComponentByPosition(1, univ.OctetString('def'))
1165        self.s1.setComponentByPosition(2, univ.Integer(123))
1166        assert list(self.s1.values()) == [str2octs('abc'), str2octs('def'), 123]
1167
1168    def testItems(self):
1169        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
1170        self.s1.setComponentByPosition(1, univ.OctetString('def'))
1171        self.s1.setComponentByPosition(2, univ.Integer(123))
1172        assert list(self.s1.items()) == [(x[0], str2octs(x[1])) for x in [('name', 'abc'), ('nick', 'def')]] + [('age', 123)]
1173
1174    def testUpdate(self):
1175        self.s1.clear()
1176        assert list(self.s1.values()) == [str2octs(''), str2octs(''), 34]
1177        self.s1.update(**{'name': 'abc', 'nick': 'def', 'age': 123})
1178        assert list(self.s1.items()) == [(x[0], str2octs(x[1])) for x in [('name', 'abc'), ('nick', 'def')]] + [('age', 123)]
1179        self.s1.update(('name', 'ABC'))
1180        assert list(self.s1.items()) == [(x[0], str2octs(x[1])) for x in [('name', 'ABC'), ('nick', 'def')]] + [('age', 123)]
1181        self.s1.update(name='CBA')
1182        assert list(self.s1.items()) == [(x[0], str2octs(x[1])) for x in [('name', 'CBA'), ('nick', 'def')]] + [('age', 123)]
1183
1184    def testStaticDef(self):
1185
1186        class Sequence(univ.Sequence):
1187            componentType = namedtype.NamedTypes(
1188                namedtype.NamedType('name', univ.OctetString('')),
1189                namedtype.OptionalNamedType('nick', univ.OctetString('')),
1190                namedtype.DefaultedNamedType('age', univ.Integer(34))
1191            )
1192
1193        s = Sequence()
1194        s['name'] = 'abc'
1195        assert s['name'] == str2octs('abc')
1196
1197
1198class SequenceWithoutSchema(BaseTestCase):
1199
1200    def testGetItem(self):
1201        s = univ.Sequence()
1202        s.setComponentByPosition(0, univ.OctetString('abc'))
1203        s[0] = 'abc'
1204        assert s['field-0']
1205        assert s[0]
1206
1207        try:
1208            s['field-1']
1209
1210        except KeyError:
1211            pass
1212
1213        else:
1214            assert False, 'KeyError not raised'
1215
1216    def testSetItem(self):
1217        s = univ.Sequence()
1218        s.setComponentByPosition(0, univ.OctetString('abc'))
1219        s['field-0'] = 'xxx'
1220
1221        try:
1222
1223            s['field-1'] = 'xxx'
1224
1225        except KeyError:
1226            pass
1227
1228        else:
1229            assert False, 'KeyError not raised'
1230
1231    def testIter(self):
1232        s = univ.Sequence()
1233        s.setComponentByPosition(0, univ.OctetString('abc'))
1234        s.setComponentByPosition(1, univ.Integer(123))
1235        assert list(s) == ['field-0', 'field-1']
1236
1237    def testKeys(self):
1238        s = univ.Sequence()
1239        s.setComponentByPosition(0, univ.OctetString('abc'))
1240        s.setComponentByPosition(1, univ.Integer(123))
1241        assert list(s.keys()) == ['field-0', 'field-1']
1242
1243    def testValues(self):
1244        s = univ.Sequence()
1245        s.setComponentByPosition(0, univ.OctetString('abc'))
1246        s.setComponentByPosition(1, univ.Integer(123))
1247        assert list(s.values()) == [str2octs('abc'), 123]
1248
1249    def testItems(self):
1250        s = univ.Sequence()
1251        s.setComponentByPosition(0, univ.OctetString('abc'))
1252        s.setComponentByPosition(1, univ.Integer(123))
1253        assert list(s.items()) == [('field-0', str2octs('abc')), ('field-1', 123)]
1254
1255    def testUpdate(self):
1256        s = univ.Sequence()
1257        assert not s
1258        s.setComponentByPosition(0, univ.OctetString('abc'))
1259        s.setComponentByPosition(1, univ.Integer(123))
1260        assert s
1261        assert list(s.keys()) == ['field-0', 'field-1']
1262        assert list(s.values()) == [str2octs('abc'), 123]
1263        assert list(s.items()) == [('field-0', str2octs('abc')), ('field-1', 123)]
1264        s['field-0'] = univ.OctetString('def')
1265        assert list(s.values()) == [str2octs('def'), 123]
1266        s['field-1'] = univ.OctetString('ghi')
1267        assert list(s.values()) == [str2octs('def'), str2octs('ghi')]
1268        try:
1269            s['field-2'] = univ.OctetString('xxx')
1270        except KeyError:
1271            pass
1272        else:
1273            assert False, 'unknown field at schema-less object tolerated'
1274        assert 'field-0' in s
1275        s.clear()
1276        assert 'field-0' not in s
1277
1278
1279class SetOf(BaseTestCase):
1280    def setUp(self):
1281        BaseTestCase.setUp(self)
1282        self.s1 = univ.SetOf(componentType=univ.OctetString(''))
1283
1284    def testTag(self):
1285        assert self.s1.tagSet == tag.TagSet(
1286            (),
1287            tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x11)
1288        ), 'wrong tagSet'
1289
1290    def testSeq(self):
1291        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
1292        assert self.s1[0] == str2octs('abc'), 'set by idx fails'
1293        self.s1.setComponentByPosition(0, self.s1[0].clone('cba'))
1294        assert self.s1[0] == str2octs('cba'), 'set by idx fails'
1295
1296    def testStaticDef(self):
1297
1298        class SetOf(univ.SequenceOf):
1299            componentType = univ.OctetString('')
1300
1301        s = SetOf()
1302        s[0] = 'abc'
1303        assert len(s) == 1
1304        assert s == [str2octs('abc')]
1305
1306
1307class Set(BaseTestCase):
1308    def setUp(self):
1309        BaseTestCase.setUp(self)
1310
1311        self.s1 = univ.Set(
1312            componentType=namedtype.NamedTypes(
1313                namedtype.NamedType('name', univ.OctetString('')),
1314                namedtype.OptionalNamedType('null', univ.Null('')),
1315                namedtype.DefaultedNamedType('age', univ.Integer(34))
1316            )
1317        )
1318        self.s2 = self.s1.clone()
1319
1320    def testTag(self):
1321        assert self.s1.tagSet == tag.TagSet(
1322            (),
1323            tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x11)
1324        ), 'wrong tagSet'
1325
1326    def testByTypeWithPythonValue(self):
1327        self.s1.setComponentByType(univ.OctetString.tagSet, 'abc')
1328        assert self.s1.getComponentByType(
1329            univ.OctetString.tagSet
1330        ) == str2octs('abc'), 'set by name fails'
1331
1332    def testByTypeWithInstance(self):
1333        self.s1.setComponentByType(univ.OctetString.tagSet, univ.OctetString('abc'))
1334        assert self.s1.getComponentByType(
1335            univ.OctetString.tagSet
1336        ) == str2octs('abc'), 'set by name fails'
1337
1338    def testGetTagMap(self):
1339        assert self.s1.tagMap.presentTypes == {
1340            univ.Set.tagSet: univ.Set()
1341        }
1342
1343    def testGetComponentTagMap(self):
1344        assert self.s1.componentType.tagMapUnique.presentTypes == {
1345            univ.OctetString.tagSet: univ.OctetString(''),
1346            univ.Null.tagSet: univ.Null(''),
1347            univ.Integer.tagSet: univ.Integer(34)
1348        }
1349
1350    def testGetPositionByType(self):
1351        assert self.s1.componentType.getPositionByType(univ.Null().tagSet) == 1
1352
1353    def testSetToDefault(self):
1354        self.s1.setComponentByName('name', univ.noValue)
1355        assert self.s1['name'] == univ.OctetString('')
1356
1357    def testIter(self):
1358        assert list(self.s1) == ['name', 'null', 'age']
1359
1360    def testStaticDef(self):
1361
1362        class Set(univ.Set):
1363            componentType = namedtype.NamedTypes(
1364                namedtype.NamedType('name', univ.OctetString('')),
1365                namedtype.OptionalNamedType('nick', univ.OctetString('')),
1366                namedtype.DefaultedNamedType('age', univ.Integer(34))
1367            )
1368
1369        s = Set()
1370        s['name'] = 'abc'
1371        assert s['name'] == str2octs('abc')
1372
1373
1374class Choice(BaseTestCase):
1375    def setUp(self):
1376        BaseTestCase.setUp(self)
1377
1378        innerComp = univ.Choice(
1379            componentType=namedtype.NamedTypes(
1380                namedtype.NamedType('count', univ.Integer()),
1381                namedtype.NamedType('flag', univ.Boolean())
1382            )
1383        )
1384        self.s1 = univ.Choice(
1385            componentType=namedtype.NamedTypes(
1386                namedtype.NamedType('name', univ.OctetString()),
1387                namedtype.NamedType('sex', innerComp)
1388            )
1389        )
1390
1391    def testTag(self):
1392        assert self.s1.tagSet == tag.TagSet(), 'wrong tagSet'
1393
1394    def testRepr(self):
1395        assert eval(repr(self.s1.clone().setComponents('a')),
1396                    {'Choice': univ.Choice, 'OctetString': univ.OctetString, 'Integer': univ.Integer,
1397                     'Boolean': univ.Boolean, 'NamedTypes': namedtype.NamedTypes,
1398                     'NamedType': namedtype.NamedType}) == self.s1.clone().setComponents('a'), 'repr() fails'
1399        assert eval(repr(self.s1.clone().setComponents(
1400            sex=self.s1.setComponentByPosition(1).getComponentByPosition(1).clone().setComponents(
1401                count=univ.Integer(123)))),
1402                    {'Choice': univ.Choice, 'OctetString': univ.OctetString, 'Integer': univ.Integer,
1403                     'Boolean': univ.Boolean, 'NamedTypes': namedtype.NamedTypes,
1404                     'NamedType': namedtype.NamedType}) == self.s1.clone().setComponents(
1405            sex=self.s1.setComponentByPosition(1).getComponentByPosition(1).clone().setComponents(
1406                count=univ.Integer(123))), 'repr() fails'
1407
1408    def testContains(self):
1409        self.s1.setComponentByType(univ.OctetString.tagSet, 'abc')
1410        assert 'name' in self.s1
1411        assert 'sex' not in self.s1
1412
1413        self.s1.setComponentByType(univ.Integer.tagSet, 123, innerFlag=True)
1414        assert 'name' not in self.s1
1415        assert 'sex' in self.s1
1416
1417    def testIter(self):
1418        self.s1.setComponentByType(univ.OctetString.tagSet, 'abc')
1419        assert list(self.s1) == ['name']
1420        self.s1.setComponentByType(univ.Integer.tagSet, 123, innerFlag=True)
1421        assert list(self.s1) == ['sex']
1422
1423    def testOuterByTypeWithPythonValue(self):
1424        self.s1.setComponentByType(univ.OctetString.tagSet, 'abc')
1425        assert self.s1.getComponentByType(
1426            univ.OctetString.tagSet
1427        ) == str2octs('abc')
1428
1429    def testOuterByTypeWithInstanceValue(self):
1430        self.s1.setComponentByType(
1431            univ.OctetString.tagSet, univ.OctetString('abc')
1432        )
1433        assert self.s1.getComponentByType(
1434            univ.OctetString.tagSet
1435        ) == str2octs('abc')
1436
1437    def testInnerByTypeWithPythonValue(self):
1438        self.s1.setComponentByType(univ.Integer.tagSet, 123, innerFlag=True)
1439        assert self.s1.getComponentByType(
1440            univ.Integer.tagSet, 1
1441        ) == 123
1442
1443    def testInnerByTypeWithInstanceValue(self):
1444        self.s1.setComponentByType(
1445            univ.Integer.tagSet, univ.Integer(123), innerFlag=True
1446        )
1447        assert self.s1.getComponentByType(
1448            univ.Integer.tagSet, 1
1449        ) == 123
1450
1451    def testCmp(self):
1452        self.s1.setComponentByName('name', univ.OctetString('abc'))
1453        assert self.s1 == str2octs('abc'), '__cmp__() fails'
1454
1455    def testGetComponent(self):
1456        self.s1.setComponentByType(univ.OctetString.tagSet, 'abc')
1457        assert self.s1.getComponent() == str2octs('abc'), 'getComponent() fails'
1458
1459    def testGetName(self):
1460        self.s1.setComponentByType(univ.OctetString.tagSet, 'abc')
1461        assert self.s1.getName() == 'name', 'getName() fails'
1462
1463    def testSetComponentByPosition(self):
1464        self.s1.setComponentByPosition(0, univ.OctetString('Jim'))
1465        assert self.s1 == str2octs('Jim')
1466
1467    def testClone(self):
1468        self.s1.setComponentByPosition(0, univ.OctetString('abc'))
1469        s = self.s1.clone()
1470        assert len(s) == 0
1471        s = self.s1.clone(cloneValueFlag=1)
1472        assert len(s) == 1
1473        assert s.getComponentByPosition(0) == self.s1.getComponentByPosition(0)
1474
1475    def testSetToDefault(self):
1476        s = self.s1.clone()
1477        s.setComponentByName('sex', univ.noValue)
1478        assert s['sex'] is not univ.noValue
1479
1480    def testStaticDef(self):
1481
1482        class InnerChoice(univ.Choice):
1483            componentType = namedtype.NamedTypes(
1484                namedtype.NamedType('count', univ.Integer()),
1485                namedtype.NamedType('flag', univ.Boolean())
1486            )
1487
1488        class OuterChoice(univ.Choice):
1489            componentType = namedtype.NamedTypes(
1490                namedtype.NamedType('name', univ.OctetString()),
1491                namedtype.NamedType('sex', InnerChoice())
1492            )
1493
1494        c = OuterChoice()
1495
1496        c.setComponentByType(univ.OctetString.tagSet, 'abc')
1497        assert c.getName() == 'name'
1498
1499
1500suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
1501
1502if __name__ == '__main__':
1503    unittest.TextTestRunner(verbosity=2).run(suite)
1504