From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- python/bitstring/test/test_bits.py | 378 +++++++++++++++++++++++++++++++++++++ 1 file changed, 378 insertions(+) create mode 100644 python/bitstring/test/test_bits.py (limited to 'python/bitstring/test/test_bits.py') diff --git a/python/bitstring/test/test_bits.py b/python/bitstring/test/test_bits.py new file mode 100644 index 000000000..402c03899 --- /dev/null +++ b/python/bitstring/test/test_bits.py @@ -0,0 +1,378 @@ +#!/usr/bin/env python + +import unittest +import sys + +sys.path.insert(0, '..') +import bitstring +from bitstring import MmapByteArray +from bitstring import Bits, BitArray, ConstByteStore, ByteStore + +class Creation(unittest.TestCase): + def testCreationFromBytes(self): + s = Bits(bytes=b'\xa0\xff') + self.assertEqual((s.len, s.hex), (16, 'a0ff')) + s = Bits(bytes=b'abc', length=0) + self.assertEqual(s, '') + + def testCreationFromBytesErrors(self): + self.assertRaises(bitstring.CreationError, Bits, bytes=b'abc', length=25) + + def testCreationFromDataWithOffset(self): + s1 = Bits(bytes=b'\x0b\x1c\x2f', offset=0, length=20) + s2 = Bits(bytes=b'\xa0\xb1\xC2', offset=4) + self.assertEqual((s2.len, s2.hex), (20, '0b1c2')) + self.assertEqual((s1.len, s1.hex), (20, '0b1c2')) + self.assertTrue(s1 == s2) + + def testCreationFromHex(self): + s = Bits(hex='0xA0ff') + self.assertEqual((s.len, s.hex), (16, 'a0ff')) + s = Bits(hex='0x0x0X') + self.assertEqual((s.length, s.hex), (0, '')) + + def testCreationFromHexWithWhitespace(self): + s = Bits(hex=' \n0 X a 4e \r3 \n') + self.assertEqual(s.hex, 'a4e3') + + def testCreationFromHexErrors(self): + self.assertRaises(bitstring.CreationError, Bits, hex='0xx0') + self.assertRaises(bitstring.CreationError, Bits, hex='0xX0') + self.assertRaises(bitstring.CreationError, Bits, hex='0Xx0') + self.assertRaises(bitstring.CreationError, Bits, hex='-2e') + # These really should fail, but it's awkward and not a big deal... +# self.assertRaises(bitstring.CreationError, Bits, '0x2', length=2) +# self.assertRaises(bitstring.CreationError, Bits, '0x3', offset=1) + + def testCreationFromBin(self): + s = Bits(bin='1010000011111111') + self.assertEqual((s.length, s.hex), (16, 'a0ff')) + s = Bits(bin='00')[:1] + self.assertEqual(s.bin, '0') + s = Bits(bin=' 0000 \n 0001\r ') + self.assertEqual(s.bin, '00000001') + + def testCreationFromBinWithWhitespace(self): + s = Bits(bin=' \r\r\n0 B 00 1 1 \t0 ') + self.assertEqual(s.bin, '00110') + + def testCreationFromOctErrors(self): + s = Bits('0b00011') + self.assertRaises(bitstring.InterpretError, s._getoct) + self.assertRaises(bitstring.CreationError, s._setoct, '8') + + def testCreationFromUintWithOffset(self): + self.assertRaises(bitstring.Error, Bits, uint=12, length=8, offset=1) + + def testCreationFromUintErrors(self): + self.assertRaises(bitstring.CreationError, Bits, uint=-1, length=10) + self.assertRaises(bitstring.CreationError, Bits, uint=12) + self.assertRaises(bitstring.CreationError, Bits, uint=4, length=2) + self.assertRaises(bitstring.CreationError, Bits, uint=0, length=0) + self.assertRaises(bitstring.CreationError, Bits, uint=12, length=-12) + + def testCreationFromInt(self): + s = Bits(int=0, length=4) + self.assertEqual(s.bin, '0000') + s = Bits(int=1, length=2) + self.assertEqual(s.bin, '01') + s = Bits(int=-1, length=11) + self.assertEqual(s.bin, '11111111111') + s = Bits(int=12, length=7) + self.assertEqual(s.int, 12) + s = Bits(int=-243, length=108) + self.assertEqual((s.int, s.length), (-243, 108)) + for length in range(6, 10): + for value in range(-17, 17): + s = Bits(int=value, length=length) + self.assertEqual((s.int, s.length), (value, length)) + s = Bits(int=10, length=8) + + def testCreationFromIntErrors(self): + self.assertRaises(bitstring.CreationError, Bits, int=-1, length=0) + self.assertRaises(bitstring.CreationError, Bits, int=12) + self.assertRaises(bitstring.CreationError, Bits, int=4, length=3) + self.assertRaises(bitstring.CreationError, Bits, int=-5, length=3) + + def testCreationFromSe(self): + for i in range(-100, 10): + s = Bits(se=i) + self.assertEqual(s.se, i) + + def testCreationFromSeWithOffset(self): + self.assertRaises(bitstring.CreationError, Bits, se=-13, offset=1) + + def testCreationFromSeErrors(self): + self.assertRaises(bitstring.CreationError, Bits, se=-5, length=33) + s = Bits(bin='001000') + self.assertRaises(bitstring.InterpretError, s._getse) + + def testCreationFromUe(self): + [self.assertEqual(Bits(ue=i).ue, i) for i in range(0, 20)] + + def testCreationFromUeWithOffset(self): + self.assertRaises(bitstring.CreationError, Bits, ue=104, offset=2) + + def testCreationFromUeErrors(self): + self.assertRaises(bitstring.CreationError, Bits, ue=-1) + self.assertRaises(bitstring.CreationError, Bits, ue=1, length=12) + s = Bits(bin='10') + self.assertRaises(bitstring.InterpretError, s._getue) + + def testCreationFromBool(self): + a = Bits('bool=1') + self.assertEqual(a, 'bool=1') + b = Bits('bool=0') + self.assertEqual(b, [0]) + c = bitstring.pack('2*bool', 0, 1) + self.assertEqual(c, '0b01') + + def testCreationKeywordError(self): + self.assertRaises(bitstring.CreationError, Bits, squirrel=5) + + def testDataStoreType(self): + a = Bits('0xf') + self.assertEqual(type(a._datastore), bitstring.ConstByteStore) + + +class Initialisation(unittest.TestCase): + def testEmptyInit(self): + a = Bits() + self.assertEqual(a, '') + + def testNoPos(self): + a = Bits('0xabcdef') + try: + a.pos + except AttributeError: + pass + else: + assert False + + def testFind(self): + a = Bits('0xabcd') + r = a.find('0xbc') + self.assertEqual(r[0], 4) + r = a.find('0x23462346246', bytealigned=True) + self.assertFalse(r) + + def testRfind(self): + a = Bits('0b11101010010010') + b = a.rfind('0b010') + self.assertEqual(b[0], 11) + + def testFindAll(self): + a = Bits('0b0010011') + b = list(a.findall([1])) + self.assertEqual(b, [2, 5, 6]) + + +class Cut(unittest.TestCase): + def testCut(self): + s = Bits(30) + for t in s.cut(3): + self.assertEqual(t, [0] * 3) + + +class InterleavedExpGolomb(unittest.TestCase): + def testCreation(self): + s1 = Bits(uie=0) + s2 = Bits(uie=1) + self.assertEqual(s1, [1]) + self.assertEqual(s2, [0, 0, 1]) + s1 = Bits(sie=0) + s2 = Bits(sie=-1) + s3 = Bits(sie=1) + self.assertEqual(s1, [1]) + self.assertEqual(s2, [0, 0, 1, 1]) + self.assertEqual(s3, [0, 0, 1, 0]) + + def testCreationFromProperty(self): + s = BitArray() + s.uie = 45 + self.assertEqual(s.uie, 45) + s.sie = -45 + self.assertEqual(s.sie, -45) + + def testInterpretation(self): + for x in range(101): + self.assertEqual(Bits(uie=x).uie, x) + for x in range(-100, 100): + self.assertEqual(Bits(sie=x).sie, x) + + def testErrors(self): + for f in ['sie=100, 0b1001', '0b00', 'uie=100, 0b1001']: + s = Bits(f) + self.assertRaises(bitstring.InterpretError, s._getsie) + self.assertRaises(bitstring.InterpretError, s._getuie) + self.assertRaises(ValueError, Bits, 'uie=-10') + + +class FileBased(unittest.TestCase): + def setUp(self): + self.a = Bits(filename='smalltestfile') + self.b = Bits(filename='smalltestfile', offset=16) + self.c = Bits(filename='smalltestfile', offset=20, length=16) + self.d = Bits(filename='smalltestfile', offset=20, length=4) + + def testCreationWithOffset(self): + self.assertEqual(self.a, '0x0123456789abcdef') + self.assertEqual(self.b, '0x456789abcdef') + self.assertEqual(self.c, '0x5678') + + def testBitOperators(self): + x = self.b[4:20] + self.assertEqual(x, '0x5678') + self.assertEqual((x & self.c).hex, self.c.hex) + self.assertEqual(self.c ^ self.b[4:20], 16) + self.assertEqual(self.a[23:36] | self.c[3:], self.c[3:]) + + def testAddition(self): + h = self.d + '0x1' + x = self.a[20:24] + self.c[-4:] + self.c[8:12] + self.assertEqual(x, '0x587') + x = self.b + x + self.assertEqual(x.hex, '456789abcdef587') + x = BitArray(x) + del x[12:24] + self.assertEqual(x, '0x456abcdef587') + +class Mmap(unittest.TestCase): + def setUp(self): + self.f = open('smalltestfile', 'rb') + + def tearDown(self): + self.f.close() + + def testByteArrayEquivalence(self): + a = MmapByteArray(self.f) + self.assertEqual(a.bytelength, 8) + self.assertEqual(len(a), 8) + self.assertEqual(a[0], 0x01) + self.assertEqual(a[1], 0x23) + self.assertEqual(a[7], 0xef) + self.assertEqual(a[0:1], bytearray([1])) + self.assertEqual(a[:], bytearray([0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef])) + self.assertEqual(a[2:4], bytearray([0x45, 0x67])) + + def testWithLength(self): + a = MmapByteArray(self.f, 3) + self.assertEqual(a[0], 0x01) + self.assertEqual(len(a), 3) + + def testWithOffset(self): + a = MmapByteArray(self.f, None, 5) + self.assertEqual(len(a), 3) + self.assertEqual(a[0], 0xab) + + def testWithLengthAndOffset(self): + a = MmapByteArray(self.f, 3, 3) + self.assertEqual(len(a), 3) + self.assertEqual(a[0], 0x67) + self.assertEqual(a[:], bytearray([0x67, 0x89, 0xab])) + + +class Comparisons(unittest.TestCase): + def testUnorderable(self): + a = Bits(5) + b = Bits(5) + self.assertRaises(TypeError, a.__lt__, b) + self.assertRaises(TypeError, a.__gt__, b) + self.assertRaises(TypeError, a.__le__, b) + self.assertRaises(TypeError, a.__ge__, b) + + +class Subclassing(unittest.TestCase): + + def testIsInstance(self): + class SubBits(bitstring.Bits): pass + a = SubBits() + self.assertTrue(isinstance(a, SubBits)) + + def testClassType(self): + class SubBits(bitstring.Bits): pass + self.assertEqual(SubBits().__class__, SubBits) + + +class LongBoolConversion(unittest.TestCase): + + def testLongBool(self): + a = Bits(1000) + b = bool(a) + self.assertTrue(b is False) + + +# Some basic tests for the private ByteStore classes + +class ConstByteStoreCreation(unittest.TestCase): + + def testProperties(self): + a = ConstByteStore(bytearray(b'abc')) + self.assertEqual(a.bytelength, 3) + self.assertEqual(a.offset, 0) + self.assertEqual(a.bitlength, 24) + self.assertEqual(a._rawarray, b'abc') + + def testGetBit(self): + a = ConstByteStore(bytearray([0x0f])) + self.assertEqual(a.getbit(0), False) + self.assertEqual(a.getbit(3), False) + self.assertEqual(a.getbit(4), True) + self.assertEqual(a.getbit(7), True) + + b = ConstByteStore(bytearray([0x0f]), 7, 1) + self.assertEqual(b.getbit(2), False) + self.assertEqual(b.getbit(3), True) + + def testGetByte(self): + a = ConstByteStore(bytearray(b'abcde'), 1, 13) + self.assertEqual(a.getbyte(0), 97) + self.assertEqual(a.getbyte(1), 98) + self.assertEqual(a.getbyte(4), 101) + + +class PadToken(unittest.TestCase): + + def testCreation(self): + a = Bits('pad:10') + self.assertEqual(a, Bits(10)) + b = Bits('pad:0') + self.assertEqual(b, Bits()) + c = Bits('0b11, pad:1, 0b111') + self.assertEqual(c, Bits('0b110111')) + + def testPack(self): + s = bitstring.pack('0b11, pad:3=5, 0b1') + self.assertEqual(s.bin, '110001') + d = bitstring.pack('pad:c', c=12) + self.assertEqual(d, Bits(12)) + e = bitstring.pack('0xf, uint:12, pad:1, bin, pad:4, 0b10', 0, '111') + self.assertEqual(e.bin, '11110000000000000111000010') + + def testUnpack(self): + s = Bits('0b111000111') + x, y = s.unpack('3, pad:3, 3') + self.assertEqual((x, y), (7, 7)) + x, y = s.unpack('2, pad:2, bin') + self.assertEqual((x, y), (3, '00111')) + x = s.unpack('pad:1, pad:2, pad:3') + self.assertEqual(x, []) + + +class ModifiedByAddingBug(unittest.TestCase): + + def testAdding(self): + a = Bits('0b0') + b = Bits('0b11') + c = a + b + self.assertEqual(c, '0b011') + self.assertEqual(a, '0b0') + self.assertEqual(b, '0b11') + + def testAdding2(self): + a = Bits(100) + b = Bits(101) + c = a + b + self.assertEqual(a, 100) + self.assertEqual(b, 101) + self.assertEqual(c, 201) -- cgit v1.2.3