1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
|
#!/usr/bin/env python
"""
Module-level unit tests.
"""
import unittest
import sys
sys.path.insert(0, '..')
import bitstring
import copy
class ModuleData(unittest.TestCase):
def testVersion(self):
self.assertEqual(bitstring.__version__, '3.1.3')
def testAll(self):
exported = ['ConstBitArray', 'ConstBitStream', 'BitStream', 'BitArray',
'Bits', 'BitString', 'pack', 'Error', 'ReadError',
'InterpretError', 'ByteAlignError', 'CreationError', 'bytealigned']
self.assertEqual(set(bitstring.__all__), set(exported))
def testReverseDict(self):
d = bitstring.BYTE_REVERSAL_DICT
for i in range(256):
a = bitstring.Bits(uint=i, length=8)
b = d[i]
self.assertEqual(a.bin[::-1], bitstring.Bits(bytes=b).bin)
def testAliases(self):
self.assertTrue(bitstring.Bits is bitstring.ConstBitArray)
self.assertTrue(bitstring.BitStream is bitstring.BitString)
class MemoryUsage(unittest.TestCase):
def testBaselineMemory(self):
try:
import pympler.asizeof.asizeof as size
except ImportError:
return
# These values might be platform dependent, so don't fret too much.
self.assertEqual(size(bitstring.ConstBitStream([0])), 64)
self.assertEqual(size(bitstring.Bits([0])), 64)
self.assertEqual(size(bitstring.BitStream([0])), 64)
self.assertEqual(size(bitstring.BitArray([0])), 64)
from bitstring.bitstore import ByteStore
self.assertEqual(size(ByteStore(bytearray())), 100)
class Copy(unittest.TestCase):
def testConstBitArrayCopy(self):
import copy
cba = bitstring.Bits(100)
cba_copy = copy.copy(cba)
self.assertTrue(cba is cba_copy)
def testBitArrayCopy(self):
ba = bitstring.BitArray(100)
ba_copy = copy.copy(ba)
self.assertFalse(ba is ba_copy)
self.assertFalse(ba._datastore is ba_copy._datastore)
self.assertTrue(ba == ba_copy)
def testConstBitStreamCopy(self):
cbs = bitstring.ConstBitStream(100)
cbs.pos = 50
cbs_copy = copy.copy(cbs)
self.assertEqual(cbs_copy.pos, 0)
self.assertTrue(cbs._datastore is cbs_copy._datastore)
self.assertTrue(cbs == cbs_copy)
def testBitStreamCopy(self):
bs = bitstring.BitStream(100)
bs.pos = 50
bs_copy = copy.copy(bs)
self.assertEqual(bs_copy.pos, 0)
self.assertFalse(bs._datastore is bs_copy._datastore)
self.assertTrue(bs == bs_copy)
class Interning(unittest.TestCase):
def testBits(self):
a = bitstring.Bits('0xf')
b = bitstring.Bits('0xf')
self.assertTrue(a is b)
c = bitstring.Bits('0b1111')
self.assertFalse(a is c)
def testCBS(self):
a = bitstring.ConstBitStream('0b11000')
b = bitstring.ConstBitStream('0b11000')
self.assertFalse(a is b)
# self.assertTrue(a._datastore is b._datastore)
|
