tests/test_compli.py

   1 """COMPLI ASN.1:2008 compliance test suite
   2
   3 COMPLI is a collection of BER-encoded examples that must behave in
   4 strictly defined way. All of them are to be valid ASN.1 encodings,
   5 however some of them do not comply with X.690-201508, so PyDERASN
   6 behaves differently in some tests. PyDERASN does not support REAL
   7 values too.
   8 """
   9
  10 from os import path
  11 from unittest import skip
  12 from unittest import TestCase
  13
  14 from pyderasn import BitString
  15 from pyderasn import Boolean
  16 from pyderasn import DecodeError
  17 from pyderasn import Integer
  18 from pyderasn import InvalidLength
  19 from pyderasn import len_decode
  20 from pyderasn import LenIndefForm
  21 from pyderasn import NotEnoughData
  22 from pyderasn import Null
  23 from pyderasn import ObjectIdentifier
  24 from pyderasn import OctetString
  25 from pyderasn import tag_decode
  26 from pyderasn import tag_strip
  27
  28
  29 test_suite_path = path.join(
  30     path.dirname(path.abspath(__file__)),
  31     "compli_test_suite",
  32     "suite",
  33 )
  34
  35
  36 def load_tc(num):
  37     with open(path.join(test_suite_path, ("tc%d.ber" % num)), "rb") as fd:
  38         return fd.read()
  39
  40
  41 class TestTestSuite(TestCase):
  42     def test_tc1(self):
  43         data = load_tc(1)
  44         tag_strip(data)
  45         tag_decode(data)
  46
  47     def test_tc2(self):
  48         data = load_tc(2)
  49         with self.assertRaisesRegex(DecodeError, "unfinished tag"):
  50             tag_strip(data)
  51
  52     def test_tc3(self):
  53         data = load_tc(3)
  54         t, _, _ = tag_strip(data)
  55         with self.assertRaises(NotEnoughData):
  56             OctetString(impl=t).decode(data)
  57
  58     def test_tc4(self):
  59         data = load_tc(4)
  60         t, _, lv = tag_strip(data)
  61         with self.assertRaises(NotEnoughData):
  62             len_decode(lv)
  63
  64     def test_tc5(self):
  65         data = load_tc(5)
  66         t, _, lv = tag_strip(data)
  67         with self.assertRaisesRegex(DecodeError, "long form instead of"):
  68             len_decode(lv)
  69
  70     @skip("PyDERASN does not support REAL")
  71     def test_tc6(self):
  72         pass
  73
  74     @skip("PyDERASN does not support REAL")
  75     def test_tc7(self):
  76         pass
  77
  78     @skip("PyDERASN does not support REAL")
  79     def test_tc8(self):
  80         pass
  81
  82     @skip("PyDERASN does not support REAL")
  83     def test_tc9(self):
  84         pass
  85
  86     @skip("PyDERASN does not support REAL")
  87     def test_tc10(self):
  88         pass
  89
  90     @skip("PyDERASN does not support REAL")
  91     def test_tc11(self):
  92         pass
  93
  94     @skip("PyDERASN does not support REAL")
  95     def test_tc12(self):
  96         pass
  97
  98     @skip("PyDERASN does not support REAL")
  99     def test_tc13(self):
 100         pass
 101
 102     @skip("PyDERASN does not support REAL")
 103     def test_tc14(self):
 104         pass
 105
 106     @skip("PyDERASN does not support REAL")
 107     def test_tc15(self):
 108         pass
 109
 110     @skip("PyDERASN does not support REAL")
 111     def test_tc16(self):
 112         pass
 113
 114     @skip("PyDERASN does not support REAL")
 115     def test_tc17(self):
 116         pass
 117
 118     def test_tc18(self):
 119         data = load_tc(18)
 120         with self.assertRaisesRegex(DecodeError, "non normalized"):
 121             Integer().decode(data)
 122
 123     def test_tc19(self):
 124         data = load_tc(19)
 125         with self.assertRaises(NotEnoughData):
 126             Integer().decode(data)
 127
 128     def test_tc20(self):
 129         data = load_tc(20)
 130         Integer().decode(data)
 131
 132     def test_tc21(self):
 133         data = load_tc(21)
 134         with self.assertRaisesRegex(DecodeError, "non normalized"):
 135             ObjectIdentifier().decode(data)
 136         ObjectIdentifier().decode(data, ctx={"bered": True})
 137
 138     def test_tc22(self):
 139         data = load_tc(22)
 140         with self.assertRaisesRegex(DecodeError, "too huge value"):
 141             ObjectIdentifier().decode(data)
 142
 143     def test_tc23(self):
 144         data = load_tc(23)
 145         with self.assertRaises(NotEnoughData):
 146             ObjectIdentifier().decode(data)
 147
 148     def test_tc24(self):
 149         data = load_tc(24)
 150         ObjectIdentifier().decode(data)
 151
 152     def test_tc25(self):
 153         # X.690-201508 8.2.1: The encoding of a boolean value shall be
 154         # primitive. The contents octets shall consist of a single octet.
 155         data = load_tc(25)
 156         with self.assertRaises(InvalidLength):
 157             Boolean().decode(data)
 158         with self.assertRaises(InvalidLength):
 159             Boolean().decode(data, ctx={"bered": True})
 160
 161     def test_tc26(self):
 162         # X.690-201508 8.2.1: The encoding of a boolean value shall be
 163         # primitive. The contents octets shall consist of a single octet.
 164         data = load_tc(26)
 165         with self.assertRaises(InvalidLength):
 166             Boolean().decode(data)
 167         with self.assertRaises(InvalidLength):
 168             Boolean().decode(data, ctx={"bered": True})
 169
 170     def test_tc27(self):
 171         data = load_tc(27)
 172         with self.assertRaises(InvalidLength):
 173             Boolean().decode(data)
 174
 175     def test_tc28(self):
 176         data = load_tc(28)
 177         self.assertTrue(bool(Boolean().decode(data)[0]))
 178
 179     def test_tc29(self):
 180         data = load_tc(29)
 181         self.assertFalse(bool(Boolean().decode(data)[0]))
 182
 183     def test_tc30(self):
 184         data = load_tc(30)
 185         with self.assertRaises(InvalidLength):
 186             Null().decode(data)
 187
 188     def test_tc31(self):
 189         data = load_tc(31)
 190         with self.assertRaises(InvalidLength):
 191             Null().decode(data)
 192
 193     def test_tc32(self):
 194         data = load_tc(32)
 195         Null().decode(data)
 196
 197     def test_tc33(self):
 198         data = load_tc(33)
 199         with self.assertRaisesRegex(DecodeError, "too big pad"):
 200             BitString().decode(data)
 201         with self.assertRaisesRegex(DecodeError, "too big pad"):
 202             BitString().decode(data, ctx={"bered": True})
 203
 204     def test_tc34(self):
 205         data = load_tc(34)
 206         with self.assertRaises(NotEnoughData):
 207             BitString().decode(data)
 208
 209     def test_tc35(self):
 210         data = load_tc(35)
 211         with self.assertRaisesRegex(DecodeError, "expected BitString encoded chunk"):
 212             BitString().decode(data, ctx={"bered": True})
 213
 214     def test_tc36(self):
 215         data = load_tc(36)
 216         with self.assertRaisesRegex(DecodeError, "invalid pad"):
 217             BitString().decode(data, ctx={"bered": True})
 218
 219     def test_tc37(self):
 220         # X.690-201508 8.6.4: To encode a bitstring value in this way,
 221         # it is segmented. Each segment shall consist of a series of
 222         # consecutive bits of the value, and with the possible exception
 223         # of the last, shall contain a number of bits which is a
 224         # multiple of eight.
 225         data = load_tc(37)
 226         with self.assertRaisesRegex(DecodeError, "invalid pad"):
 227             BitString().decode(data, ctx={"bered": True})
 228
 229     def test_tc38(self):
 230         data = load_tc(38)
 231         BitString().decode(data, ctx={"bered": True})
 232
 233     def test_tc39(self):
 234         # X.690-201508 8.6.2: The contents octets for the primitive
 235         # encoding shall contain an initial octet followed by zero, one
 236         # or more subsequent octets.
 237         # X.690-201508 8.6.2.3: If the bitstring is empty, there shall
 238         # be no subsequent octets, and the initial octet shall be zero.
 239         data = load_tc(39)
 240         with self.assertRaises(NotEnoughData):
 241             BitString().decode(data, ctx={"bered": True})
 242
 243     def test_tc40(self):
 244         # X.690-201508 8.6.2: The contents octets for the primitive
 245         # encoding shall contain an initial octet followed by zero, one
 246         # or more subsequent octets.
 247         # X.690-201508 8.6.2.3: If the bitstring is empty, there shall
 248         # be no subsequent octets, and the initial octet shall be zero.
 249         data = load_tc(40)
 250         with self.assertRaises(NotEnoughData):
 251             BitString().decode(data, ctx={"bered": True})
 252
 253     def test_tc41(self):
 254         data = load_tc(41)
 255         with self.assertRaisesRegex(DecodeError, "expected OctetString encoded chunk"):
 256             OctetString().decode(data, ctx={"bered": True})
 257
 258     def test_tc42(self):
 259         data = load_tc(42)
 260         with self.assertRaises(NotEnoughData):
 261             OctetString().decode(data, ctx={"bered": True})
 262
 263     def test_tc43(self):
 264         data = load_tc(43)
 265         with self.assertRaises(NotEnoughData):
 266             OctetString().decode(data, ctx={"bered": True})
 267
 268     def test_tc44(self):
 269         data = load_tc(44)
 270         OctetString().decode(data)
 271
 272     def test_tc45(self):
 273         data = load_tc(45)
 274         OctetString().decode(data, ctx={"bered": True})
 275
 276     def test_tc46(self):
 277         data = load_tc(46)
 278         with self.assertRaises(LenIndefForm):
 279             BitString().decode(data, ctx={"bered": True})
 280
 281     def test_tc47(self):
 282         data = load_tc(47)
 283         with self.assertRaisesRegex(DecodeError, "expected BitString encoded chunk"):
 284             BitString().decode(data, ctx={"bered": True})
 285
 286     def test_tc48(self):
 287         data = load_tc(48)
 288         with self.assertRaisesRegex(DecodeError, "too big pad"):
 289             BitString().decode(data, ctx={"bered": True})