Package ldaptor :: Package test :: Module test_pureber
[hide private]
[frames] | no frames]

Source Code for Module ldaptor.test.test_pureber

  1  # Ldaptor -- TODO 
  2  # Copyright (C) 2001 Matthew W. Lefkowitz 
  3  # 
  4  # This library is free software; you can redistribute it and/or 
  5  # modify it under the terms of version 2.1 of the GNU Lesser General Public 
  6  # License as published by the Free Software Foundation. 
  7  # 
  8  # This library is distributed in the hope that it will be useful, 
  9  # but WITHOUT ANY WARRANTY; without even the implied warranty of 
 10  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
 11  # Lesser General Public License for more details. 
 12  # 
 13  # You should have received a copy of the GNU Lesser General Public 
 14  # License along with this library; if not, write to the Free Software 
 15  # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 16   
 17  """ 
 18  Test cases for ldaptor.protocols.pureber module. 
 19  """ 
 20   
 21  from twisted.trial import unittest 
 22  from ldaptor.protocols import pureber 
 23  import types 
 24   
25 -def s(*l):
26 """Join all members of list to a string. Integer members are chr()ed""" 27 r='' 28 for e in l: 29 if isinstance(e, types.IntType): 30 e=chr(e) 31 r=r+str(e) 32 return r
33
34 -def l(s):
35 """Split a string to ord's of chars.""" 36 return map(lambda x: ord(x), s)
37
38 -class BerLengths(unittest.TestCase):
39 knownValues=( 40 (0, [0]), 41 (1, [1]), 42 (100, [100]), 43 (126, [126]), 44 (127, [127]), 45 (128, [0x80|1, 128]), 46 (129, [0x80|1, 129]), 47 (255, [0x80|1, 255]), 48 (256, [0x80|2, 1, 0]), 49 (257, [0x80|2, 1, 1]), 50 (65535, [0x80|2, 0xFF, 0xFF]), 51 (65536, [0x80|3, 0x01, 0x00, 0x00]), 52 (256**127-1, [0x80|127]+127*[0xFF]), 53 ) 54
55 - def testToBER(self):
56 for integer, encoded in self.knownValues: 57 got = pureber.int2berlen(integer) 58 got = str(got) 59 got = map(ord, got) 60 self.assertEquals(got, encoded)
61
62 - def testFromBER(self):
63 for integer, encoded in self.knownValues: 64 m=s(*encoded) 65 got, bytes = pureber.berDecodeLength(m) 66 self.assertEquals(bytes, len(m)) 67 self.assertEquals(got, integer)
68
69 - def testPartialBER(self):
70 m=str(pureber.int2berlen(3*256)) 71 assert len(m)==3 72 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeLength, m[:2]) 73 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeLength, m[:1]) 74 75 m=str(pureber.int2berlen(256**100-1)) 76 assert len(m)==101 77 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeLength, m[:100])
78
79 -class BERBaseEquality(unittest.TestCase):
80 valuesToTest=( 81 (pureber.BERInteger, [0]), 82 (pureber.BERInteger, [1]), 83 (pureber.BERInteger, [4000]), 84 (pureber.BERSequence, [[pureber.BERInteger(1000), pureber.BERInteger(2000)]]), 85 (pureber.BERSequence, [[pureber.BERInteger(2000), pureber.BERInteger(1000)]]), 86 (pureber.BEROctetString, ["foo"]), 87 (pureber.BEROctetString, ["b"+chr(0xe4)+chr(0xe4)]), 88 ) 89
90 - def testBERBaseEquality(self):
91 """BER objects equal BER objects with same type and content""" 92 for class_, args in self.valuesToTest: 93 x=class_(*args) 94 y=class_(*args) 95 assert x==x 96 assert x==y
97
98 - def testBERBaseInEquality(self):
99 """BER objects do not equal BER objects with different type or content""" 100 for i in xrange(len(self.valuesToTest)): 101 for j in xrange(len(self.valuesToTest)): 102 if i!=j: 103 i_class, i_args = self.valuesToTest[i] 104 j_class, j_args = self.valuesToTest[j] 105 x=i_class(*i_args) 106 y=j_class(*j_args) 107 assert x!=y
108 109
110 -class BERIntegerKnownValues(unittest.TestCase):
111 knownValues=( 112 (0, [0x02, 0x01, 0]), 113 (1, [0x02, 0x01, 1]), 114 (2, [0x02, 0x01, 2]), 115 (125, [0x02, 0x01, 125]), 116 (126, [0x02, 0x01, 126]), 117 (127, [0x02, 0x01, 127]), 118 (-1, [0x02, 0x01, 256-1]), 119 (-2, [0x02, 0x01, 256-2]), 120 (-3, [0x02, 0x01, 256-3]), 121 (-126, [0x02, 0x01, 256-126]), 122 (-127, [0x02, 0x01, 256-127]), 123 (-128, [0x02, 0x01, 256-128]), 124 (-129, [0x02, 0x02, 256-1, 256-129]), 125 (128, [0x02, 0x02, 0, 128]), 126 (256, [0x02, 0x02, 1, 0]), 127 ) 128
130 """str(BERInteger(n)) should give known result with known input""" 131 for integer, encoded in self.knownValues: 132 result = pureber.BERInteger(integer) 133 result = str(result) 134 result = map(ord, result) 135 assert encoded==result
136
138 """BERInteger(encoded="...") should give known result with known input""" 139 for integer, encoded in self.knownValues: 140 m=s(*encoded) 141 result, bytes = pureber.berDecodeObject(pureber.BERDecoderContext(), m) 142 self.assertEquals(bytes, len(m)) 143 assert isinstance(result, pureber.BERInteger) 144 result = result.value 145 assert integer==result
146
148 """BERInteger(encoded="...") with too short input should throw BERExceptionInsufficientData""" 149 m=str(pureber.BERInteger(42)) 150 assert len(m)==3 151 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeObject, pureber.BERDecoderContext(), m[:2]) 152 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeObject, pureber.BERDecoderContext(), m[:1]) 153 self.assertEquals((None, 0), pureber.berDecodeObject(pureber.BERDecoderContext(), ''))
154
155 -class BERIntegerSanityCheck(unittest.TestCase):
156 - def testSanity(self):
157 """BERInteger(encoded=BERInteger(n)).value==n for -1000..1000""" 158 for n in range(-1000, 1001, 10): 159 encoded = str(pureber.BERInteger(n)) 160 result, bytes = pureber.berDecodeObject(pureber.BERDecoderContext(), encoded) 161 self.assertEquals(bytes, len(encoded)) 162 assert isinstance(result, pureber.BERInteger) 163 result = result.value 164 assert n==result
165 166 167
168 -class ObjectThatCanStringify(object):
169 - def __str__(self):
170 return "bar"
171
172 -class BEROctetStringKnownValues(unittest.TestCase):
173 knownValues=( 174 ("", [0x04, 0]), 175 ("foo", [0x04, 3]+l("foo")), 176 (100*"x", [0x04, 100]+l(100*"x")), 177 (ObjectThatCanStringify(), [0x04, 3]+l("bar")), 178 ) 179
181 """str(BEROctetString(n)) should give known result with known input""" 182 for st, encoded in self.knownValues: 183 result = pureber.BEROctetString(st) 184 result = str(result) 185 result = map(ord, result) 186 assert encoded==result
187
189 """BEROctetString(encoded="...") should give known result with known input""" 190 for st, encoded in self.knownValues: 191 m=s(*encoded) 192 result, bytes = pureber.berDecodeObject(pureber.BERDecoderContext(), m) 193 self.assertEquals(bytes, len(m)) 194 assert isinstance(result, pureber.BEROctetString) 195 result = str(result) 196 result = map(ord, result) 197 assert encoded==result
198
200 """BEROctetString(encoded="...") with too short input should throw BERExceptionInsufficientData""" 201 m=str(pureber.BEROctetString("x")) 202 assert len(m)==3 203 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeObject, pureber.BERDecoderContext(), m[:2]) 204 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeObject, pureber.BERDecoderContext(), m[:1]) 205 self.assertEquals((None, 0), pureber.berDecodeObject(pureber.BERDecoderContext(), ''))
206
207 -class BEROctetStringSanityCheck(unittest.TestCase):
208 - def testSanity(self):
209 """BEROctetString(encoded=BEROctetString(n*'x')).value==n*'x' for some values of n""" 210 for n in 0,1,2,3,4,5,6,100,126,127,128,129,1000,2000: 211 encoded = str(pureber.BEROctetString(n*'x')) 212 result, bytes = pureber.berDecodeObject(pureber.BERDecoderContext(), encoded) 213 self.assertEquals(bytes, len(encoded)) 214 assert isinstance(result, pureber.BEROctetString) 215 result = result.value 216 assert n*'x'==result
217 218 219 220 221 222 223 224 225 226 227 228
229 -class BERNullKnownValues(unittest.TestCase):
230 - def testToBERNullKnownValues(self):
231 """str(BERNull()) should give known result""" 232 result = pureber.BERNull() 233 result = str(result) 234 result = map(ord, result) 235 assert [0x05, 0x00]==result
236
238 """BERNull(encoded="...") should give known result with known input""" 239 encoded=[0x05, 0x00] 240 m=s(*encoded) 241 result, bytes = pureber.berDecodeObject(pureber.BERDecoderContext(), m) 242 self.assertEquals(bytes, len(m)) 243 assert isinstance(result, pureber.BERNull) 244 assert 0x05==result.tag
245
247 """BERNull(encoded="...") with too short input should throw BERExceptionInsufficientData""" 248 m=str(pureber.BERNull()) 249 assert len(m)==2 250 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeObject, pureber.BERDecoderContext(), m[:1]) 251 self.assertEquals((None, 0), pureber.berDecodeObject(pureber.BERDecoderContext(), ''))
252 253 254 255 256
257 -class BERBooleanKnownValues(unittest.TestCase):
258 knownValues=( 259 (0, [0x01, 0x01, 0], 0), 260 (1, [0x01, 0x01, 0xFF], 0xFF), 261 (2, [0x01, 0x01, 0xFF], 0xFF), 262 (125, [0x01, 0x01, 0xFF], 0xFF), 263 (126, [0x01, 0x01, 0xFF], 0xFF), 264 (127, [0x01, 0x01, 0xFF], 0xFF), 265 (-1, [0x01, 0x01, 0xFF], 0xFF), 266 (-2, [0x01, 0x01, 0xFF], 0xFF), 267 (-3, [0x01, 0x01, 0xFF], 0xFF), 268 (-126, [0x01, 0x01, 0xFF], 0xFF), 269 (-127, [0x01, 0x01, 0xFF], 0xFF), 270 (-128, [0x01, 0x01, 0xFF], 0xFF), 271 (-129, [0x01, 0x01, 0xFF], 0xFF), 272 (-9999, [0x01, 0x01, 0xFF], 0xFF), 273 (128, [0x01, 0x01, 0xFF], 0xFF), 274 (255, [0x01, 0x01, 0xFF], 0xFF), 275 (256, [0x01, 0x01, 0xFF], 0xFF), 276 (9999, [0x01, 0x01, 0xFF], 0xFF), 277 ) 278
280 """str(BERBoolean(n)) should give known result with known input""" 281 for integer, encoded, dummy in self.knownValues: 282 result = pureber.BERBoolean(integer) 283 result = str(result) 284 result = map(ord, result) 285 assert encoded==result
286
288 """BERBoolean(encoded="...") should give known result with known input""" 289 for integer, encoded, canon in self.knownValues: 290 m=s(*encoded) 291 result, bytes = pureber.berDecodeObject(pureber.BERDecoderContext(), m) 292 self.assertEquals(bytes, len(m)) 293 assert isinstance(result, pureber.BERBoolean) 294 result = result.value 295 assert result==canon
296
298 """BERBoolean(encoded="...") with too short input should throw BERExceptionInsufficientData""" 299 m=str(pureber.BERBoolean(42)) 300 assert len(m)==3 301 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeObject, pureber.BERDecoderContext(), m[:2]) 302 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeObject, pureber.BERDecoderContext(), m[:1]) 303 self.assertEquals((None, 0), pureber.berDecodeObject(pureber.BERDecoderContext(), ''))
304 305 306 307 308 309 310 311
312 -class BEREnumeratedKnownValues(unittest.TestCase):
313 knownValues=( 314 (0, [0x0a, 0x01, 0]), 315 (1, [0x0a, 0x01, 1]), 316 (2, [0x0a, 0x01, 2]), 317 (125, [0x0a, 0x01, 125]), 318 (126, [0x0a, 0x01, 126]), 319 (127, [0x0a, 0x01, 127]), 320 (-1, [0x0a, 0x01, 256-1]), 321 (-2, [0x0a, 0x01, 256-2]), 322 (-3, [0x0a, 0x01, 256-3]), 323 (-126, [0x0a, 0x01, 256-126]), 324 (-127, [0x0a, 0x01, 256-127]), 325 (-128, [0x0a, 0x01, 256-128]), 326 (-129, [0x0a, 0x02, 256-1, 256-129]), 327 (128, [0x0a, 0x02, 0, 128]), 328 (256, [0x0a, 0x02, 1, 0]), 329 ) 330
332 """str(BEREnumerated(n)) should give known result with known input""" 333 for integer, encoded in self.knownValues: 334 result = pureber.BEREnumerated(integer) 335 result = str(result) 336 result = map(ord, result) 337 assert encoded==result
338
340 """BEREnumerated(encoded="...") should give known result with known input""" 341 for integer, encoded in self.knownValues: 342 m=s(*encoded) 343 result, bytes = pureber.berDecodeObject(pureber.BERDecoderContext(), m) 344 self.assertEquals(bytes, len(m)) 345 assert isinstance(result, pureber.BEREnumerated) 346 result = result.value 347 assert integer==result
348
350 """BEREnumerated(encoded="...") with too short input should throw BERExceptionInsufficientData""" 351 m=str(pureber.BEREnumerated(42)) 352 assert len(m)==3 353 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeObject, pureber.BERDecoderContext(), m[:2]) 354 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeObject, pureber.BERDecoderContext(), m[:1]) 355 self.assertEquals((None, 0), pureber.berDecodeObject(pureber.BERDecoderContext(), ''))
356 357
358 -class BEREnumeratedSanityCheck(unittest.TestCase):
359 - def testSanity(self):
360 """BEREnumerated(encoded=BEREnumerated(n)).value==n for -1000..1000""" 361 for n in range(-1000, 1001, 10): 362 encoded = str(pureber.BEREnumerated(n)) 363 result, bytes = pureber.berDecodeObject(pureber.BERDecoderContext(), encoded) 364 self.assertEquals(bytes, len(encoded)) 365 assert isinstance(result, pureber.BEREnumerated) 366 result = result.value 367 assert n==result
368 369
370 -class BERSequenceKnownValues(unittest.TestCase):
371 knownValues=( 372 ([], [0x30, 0x00]), 373 ([pureber.BERInteger(2)], [0x30, 0x03, 0x02, 0x01, 2]), 374 ([pureber.BERInteger(3)], [0x30, 0x03, 0x02, 0x01, 3]), 375 ([pureber.BERInteger(128)], [0x30, 0x04, 0x02, 0x02, 0, 128]), 376 ([pureber.BERInteger(2), pureber.BERInteger(3), pureber.BERInteger(128)], 377 [0x30, 0x0a]+[0x02, 0x01, 2]+[0x02, 0x01, 3]+[0x02, 0x02, 0, 128]), 378 ) 379
381 """str(BERSequence(x)) should give known result with known input""" 382 for content, encoded in self.knownValues: 383 result = pureber.BERSequence(content) 384 result = str(result) 385 result = map(ord, result) 386 assert encoded==result
387
389 """BERSequence(encoded="...") should give known result with known input""" 390 for content, encoded in self.knownValues: 391 m=s(*encoded) 392 result, bytes = pureber.berDecodeObject(pureber.BERDecoderContext(), m) 393 self.assertEquals(bytes, len(m)) 394 assert isinstance(result, pureber.BERSequence) 395 result = result.data 396 assert len(content)==len(result) 397 for i in xrange(len(content)): 398 assert content[i]==result[i] 399 assert content==result
400
402 """BERSequence(encoded="...") with too short input should throw BERExceptionInsufficientData""" 403 m=str(pureber.BERSequence([pureber.BERInteger(2)])) 404 assert len(m)==5 405 406 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeObject, pureber.BERDecoderContext(), m[:4]) 407 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeObject, pureber.BERDecoderContext(), m[:3]) 408 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeObject, pureber.BERDecoderContext(), m[:2]) 409 self.assertRaises(pureber.BERExceptionInsufficientData, pureber.berDecodeObject, pureber.BERDecoderContext(), m[:1]) 410 self.assertEquals((None, 0), pureber.berDecodeObject(pureber.BERDecoderContext(), ''))
411 412 # TODO BERSequenceOf 413 # TODO BERSet 414