def test_bitview_getitem__single_byte_bitslice_with_bits(self): for i in range(0, 256): for j in range(0, 8): bv = BitView(bytearray([i])) bv_slice = bv[float(j) / 8:] ba = bitarray(endian='little') ba.frombytes(chr(i) if PY2 else bytes([i])) ba_slice = ba[j:] self.assertEqualBitArrayBitView(ba_slice, bv_slice)
def test_bitview__positive_slicing(self): for i in range(0, 100): ba = self._create_random_bit_array() bv = BitView(self._bitarray_to_bytes(ba), stop=float(ba.length()) / 8) self.assertEqualBitArrayBitView(ba, bv) slice_start_in_bits = random.choice(range(0, ba.length() + 10)) slice_end_in_bits = random.choice(range(slice_start_in_bits, ba.length() + 10)) ba_slice = ba[slice_start_in_bits:slice_end_in_bits] bv_slice = bv[float(slice_start_in_bits) / 8:float(slice_end_in_bits) / 8] self.assertEqualBitArrayBitView(ba_slice, bv_slice)
def test_bitview__positive_slicing(self): for i in range(0, 100): ba = self._create_random_bit_array() bv = BitView(self._bitarray_to_bytes(ba), stop=float(ba.length()) / 8) self.assertEqualBitArrayBitView(ba, bv) slice_start_in_bits = random.choice(range(0, ba.length() + 10)) slice_end_in_bits = random.choice( range(slice_start_in_bits, ba.length() + 10)) ba_slice = ba[slice_start_in_bits:slice_end_in_bits] bv_slice = bv[float(slice_start_in_bits) / 8:float(slice_end_in_bits) / 8] self.assertEqualBitArrayBitView(ba_slice, bv_slice)
def test_buffer_bits__simple(self): class Foo(Buffer): f_int = int_field(sign='unsigned', where=(bytes_ref[7].bits[0:4] + bytes_ref[6].bits[0:4] + bytes_ref[5].bits[0:4] + bytes_ref[4].bits[0:4] + bytes_ref[3].bits[0:4] + bytes_ref[2].bits[0:4] + bytes_ref[1].bits[0:4] + bytes_ref[0].bits[0:4])) self.assertEqual(7.5, Foo.byte_size) for n in (0x12345678, 0x87654321, 0, 1, 0x10000000, 0xFF000000): foo = Foo() foo.f_int = n packed_value = foo.pack() self.assertEqual(8, len(packed_value)) packed_result = bytearray(8) for i in range(8): packed_result[7 - i] = (foo.f_int >> (i * 4)) & 0x0F self.assertEqual(packed_result, packed_value) foo = Foo() foo.unpack(packed_result) self.assertEqual(foo.f_int, n)
def evaluate(self, ctx): range_list = self.parent_range_ref.deref(ctx) assert len(range_list) >= 1 bit_range = SequentialRange(float(self.start.deref(ctx)) / 8, float(self.stop.deref(ctx)) / 8) i, sum_length = range_list.find_relative_container_index(bit_range.start) if i is None: raise ValueError("Bit offset {0} is out of range for range sequence {1!r}".format( int(bit_range.start * 8), range_list)) if bit_range.is_open(): subrange_start = range_list[i].start + bit_range.start - sum_length return SequentialRangeList([SequentialRange(subrange_start, range_list[i].stop)] + range_list[i + 1:]) bit_range_remaining_len = bit_range.byte_length() result = [] for i in range(i, len(range_list)): r = range_list[i] subrange_start = r.start + bit_range.start - sum_length if r.is_open() or (r.stop - subrange_start) >= bit_range_remaining_len: subrange_stop = subrange_start + bit_range_remaining_len else: subrange_stop = r.stop result.append(SequentialRange(subrange_start, subrange_stop)) bit_range_remaining_len -= (subrange_stop - subrange_start) if bit_range_remaining_len == 0: break if bit_range_remaining_len > 0: raise ValueError("Bit range {0!r} is out of range for parent range {1!r}".format(bit_range, range_list)) return SequentialRangeList(result)
def test_iadd_1(self): a = bytearray(b'\xd3\x94Q`\xb1\x93\x17\xed\xb2W\xa5\x00') b = bytearray(b'MK\xa3Li\xf9>\x039') bv1 = BitAwareByteArray(bytearray(a), start=0, stop=11.125) bv2 = BitView(bytearray(b), start=0, stop=8.75) bv1 += bv2 a[-1] &= 0x01 a[-1] |= (b[0] & 0x7F) << 1 for i in range(len(b) - 1): a.append((b[i] >> 7) + ((b[i + 1] & 0x7F) << 1)) self.assertEquals(list(bv1), list(a))
def evaluate(self, ctx): range_list = self.parent_range_ref.deref(ctx) assert len(range_list) >= 1 bit_range = SequentialRange( float(self.start.deref(ctx)) / 8, float(self.stop.deref(ctx)) / 8) i, sum_length = range_list.find_relative_container_index( bit_range.start) if i is None: raise ValueError( "Bit offset {0} is out of range for range sequence {1!r}". format(int(bit_range.start * 8), range_list)) if bit_range.is_open(): subrange_start = range_list[i].start + bit_range.start - sum_length return SequentialRangeList( [SequentialRange(subrange_start, range_list[i].stop)] + range_list[i + 1:]) bit_range_remaining_len = bit_range.byte_length() result = [] for i in range(i, len(range_list)): r = range_list[i] subrange_start = r.start + bit_range.start - sum_length if r.is_open() or (r.stop - subrange_start) >= bit_range_remaining_len: subrange_stop = subrange_start + bit_range_remaining_len else: subrange_stop = r.stop result.append(SequentialRange(subrange_start, subrange_stop)) bit_range_remaining_len -= (subrange_stop - subrange_start) if bit_range_remaining_len == 0: break if bit_range_remaining_len > 0: raise ValueError( "Bit range {0!r} is out of range for parent range {1!r}". format(bit_range, range_list)) return SequentialRangeList(result)
def test_buffer_bits__complex(self): class Foo(Buffer): f_int = int_field(sign='unsigned', where=(bytes_ref[0:2].bits[4:12] + bytes_ref[2:4].bits[4:12] + bytes_ref[4:6].bits[4:12] + bytes_ref[6:8].bits[4:12])) self.assertEqual(7.5, Foo.byte_size) for n in (0xFF000000, 0x12345678, 0x87654321, 0, 1, 0x10000000, 0xFF000000): foo = Foo() foo.f_int = n packed_value = foo.pack() self.assertEqual(8, len(packed_value)) ba = bitarray('0' * (8 * 8), endian='little') int_pack = struct.pack("<L", foo.f_int) for i in range(4): b = bitarray(endian='little') b.frombytes(bytes([int_pack[i]]) if not PY2 else int_pack[i]) ba[i * 2 * 8 + 4:i * 2 * 8 + 4 + 8] = b self.assertEqual(ba.tobytes(), packed_value)
def test_buffer_bits__simple(self): class Foo(Buffer): f_int = int_field( sign='unsigned', where=(bytes_ref[7].bits[0:4] + bytes_ref[6].bits[0:4] + bytes_ref[5].bits[0:4] + bytes_ref[4].bits[0:4] + bytes_ref[3].bits[0:4] + bytes_ref[2].bits[0:4] + bytes_ref[1].bits[0:4] + bytes_ref[0].bits[0:4])) self.assertEqual(7.5, Foo.byte_size) for n in (0x12345678, 0x87654321, 0, 1, 0x10000000, 0xFF000000): foo = Foo() foo.f_int = n packed_value = foo.pack() self.assertEqual(8, len(packed_value)) packed_result = bytearray(8) for i in range(8): packed_result[7 - i] = (foo.f_int >> (i * 4)) & 0x0F self.assertEqual(packed_result, packed_value) foo = Foo() foo.unpack(packed_result) self.assertEqual(foo.f_int, n)
def test_buffer_bits__complex(self): class Foo(Buffer): f_int = int_field( sign='unsigned', where=(bytes_ref[0:2].bits[4:12] + bytes_ref[2:4].bits[4:12] + bytes_ref[4:6].bits[4:12] + bytes_ref[6:8].bits[4:12])) self.assertEqual(7.5, Foo.byte_size) for n in (0xFF000000, 0x12345678, 0x87654321, 0, 1, 0x10000000, 0xFF000000): foo = Foo() foo.f_int = n packed_value = foo.pack() self.assertEqual(8, len(packed_value)) ba = bitarray('0' * (8 * 8), endian='little') int_pack = struct.pack("<L", foo.f_int) for i in range(4): b = bitarray(endian='little') b.frombytes(bytes([int_pack[i]]) if not PY2 else int_pack[i]) ba[i * 2 * 8 + 4:i * 2 * 8 + 4 + 8] = b self.assertEqual(ba.tobytes(), packed_value)
def test_bitview_getitem__single_byte_bitslice(self): for i in range(0, 256): for j in range(0, 8): bv = BitView(bytearray([i])) self.assertEqual(list(bv[float(j) / 8:])[0], i >> j)
def junk_generator(size): import string import random chars = string.ascii_letters + string.digits + string.punctuation return ''.join(random.choice(chars) for x in range(size)).encode('ASCII')
def _create_random_bit_array(self): length_in_bits = random.randint(0, 8 * 16) return bitarray("".join( random.choice(('0', '1')) for i in range(length_in_bits)), endian='little')
def _create_random_bit_array(self): length_in_bits = random.randint(0, 8 * 16) return bitarray("".join(random.choice(('0', '1')) for i in range(length_in_bits)), endian='little')