1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
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
35 """Split a string to ord's of chars."""
36 return map(lambda x: ord(x), s)
37
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
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
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
78
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
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
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
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
146
154
165
166
167
171
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
198
206
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
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
245
252
253
254
255
256
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
296
304
305
306
307
308
309
310
311
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
348
356
357
368
369
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
413
414