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