def test_conditional(): true_data = bitstring.BitArray(bytearray([0b11001010, 0b11101000])) true_data.append('0b0') true_test = b.parse(true_data, conditional_test) assert true_test._length == 13 assert true_test.qux assert hasattr(true_test, "frooz") assert not hasattr(true_test, "fooz") assert true_test.frooz == 0b1001 assert true_test.quxz == 0b01011101 written_bytes = b.write(true_test, conditional_test) expected_bytes = bytearray([0b11001010, 0b11101000]) assert written_bytes == expected_bytes false_data = bitstring.BitArray( bytearray([0b01001000, 0b10000000])) false_data.append('0b1') false_test = b.parse(false_data, conditional_test) assert false_test._length == 17 assert not false_test.qux assert hasattr(false_test, "fooz") assert not hasattr(false_test, "frooz") assert false_test.fooz == 0b10010001 assert false_test.barz == 1 written_bytes = b.write(false_test, conditional_test) expected_bytes = bytearray([0b01001000, 0b10000000, 0b10000000]) assert written_bytes == expected_bytes
def test_conditional(): true_data = bitstring.BitArray(bytearray([0b11001010, 0b11101000])) true_data.append('0b0') true_test = b.parse(true_data, conditional_test) assert_equal(true_test.qux, True) assert_true(hasattr(true_test, "frooz")) assert_false(hasattr(true_test, "fooz")) assert_equal(true_test.frooz, 0b1001) assert_equal(true_test.quxz, 0b01011101) assert_equal(b.write(true_test, conditional_test), bytearray([0b11001010, 0b11101000, 0])) false_data = bitstring.BitArray( bytearray([0b01001000, 0b10000000])) false_data.append('0b1') false_test = b.parse(false_data, conditional_test) assert_equal(false_test.qux, False) assert_true(hasattr(false_test, "fooz")) assert_false(hasattr(false_test, "frooz")) assert_equal(false_test.fooz, 0b10010001) assert_equal(false_test.barz, 1) assert_equal(b.write(false_test, conditional_test), bytearray([0b01001000, 0b10000000, 0b10000000]))
def test_enum_multiple_values_same_key(): enum_test = [ ('waveform', b.enum(8, { 0: 'triangle', 1: 'saw down', 2: 'saw up', 3: 'square', 4: 'sine', (5, 7): 'sample and hold' })) ] data = bytearray([7]) result = b.parse(data, enum_test) assert result.waveform == 'sample and hold' dumped = b.write(result, enum_test) assert dumped == bytearray([7]) data = bytearray([5]) result = b.parse(data, enum_test) assert result.waveform == 'sample and hold' data = bytearray([2]) result = b.parse(data, enum_test) assert result.waveform == 'saw up' test_struct = b.new(enum_test) test_struct.waveform = 'sample and hold' dumped = b.write(test_struct, enum_test) assert dumped == bytearray([5])
def test_enum(): enum_test = [("suit", b.enum(8, { 0: "diamonds", 1: "hearts", 2: "spades", 3: "clubs" }))] for value, suit in zip(list(range(4)), ["diamonds", "hearts", "spades", "clubs"]): data = bytearray([value]) result = b.parse(data, enum_test) assert_equal(result.suit, suit) assert_equal(b.write(result, enum_test), data) spades_test = b.parse([2], enum_test) spades_test.suit = "clubs" assert_equal(bytearray([3]), b.write(spades_test)) def get_data_field(): data = bytearray([42]) result = b.parse(data, enum_test) result.suit assert_raises(ValueError, get_data_field)
def test_conditional(): conditional_test = [ ("qux", b.boolean), (b.CONDITIONAL, "qux", { False: [("fooz", b.byte), ("barz", b.byte)], True: [("frooz", b.nibble), ("quxz", b.byte)] }) ] true_data = bytearray([0b11001010, 0b11101000]) true_test = b.parse(true_data, conditional_test) assert true_test.qux == True assert hasattr(true_test, "frooz") assert not hasattr(true_test, "fooz") assert true_test.frooz == 0b1001 assert true_test.quxz == 0b01011101 assert_equal(b.write(true_test, conditional_test), true_data) false_data = bytearray([0b01001000, 0b10000000, 0b10000000]) false_test = b.parse(false_data, conditional_test) assert false_test.qux == False assert hasattr(false_test, "fooz") assert not hasattr(false_test, "frooz") assert false_test.fooz == 0b10010001 assert false_test.barz == 1 assert b.write(false_test, conditional_test) == false_data
def test_conditional(): true_data = bitstring.BitArray(bytearray([0b11001010, 0b11101000])) true_data.append('0b0') true_test = b.parse(true_data, conditional_test) assert_equal(true_test.qux, True) assert_true(hasattr(true_test, "frooz")) assert_false(hasattr(true_test, "fooz")) assert_equal(true_test.frooz, 0b1001) assert_equal(true_test.quxz, 0b01011101) assert_equal(b.write(true_test, conditional_test), bytearray([0b11001010, 0b11101000, 0])) false_data = bitstring.BitArray(bytearray([0b01001000, 0b10000000])) false_data.append('0b1') false_test = b.parse(false_data, conditional_test) assert_equal(false_test.qux, False) assert_true(hasattr(false_test, "fooz")) assert_false(hasattr(false_test, "frooz")) assert_equal(false_test.fooz, 0b10010001) assert_equal(false_test.barz, 1) assert_equal(b.write(false_test, conditional_test), bytearray([0b01001000, 0b10000000, 0b10000000]))
def test_enum(): enum_test = [ ("suit", b.enum(8, { 0: "diamonds", 1: "hearts", 2: "spades", 3: "clubs" }))] for value, suit in zip( list(range(4)), ["diamonds", "hearts", "spades", "clubs"]): data = bytearray([value]) result = b.parse(data, enum_test) assert_equal(result.suit, suit) assert_equal(b.write(result, enum_test), data) spades_test = b.parse([2], enum_test) spades_test.suit = "clubs" assert_equal(bytearray([3]), b.write(spades_test)) def get_data_field(): data = bytearray([42]) result = b.parse(data, enum_test) result.suit assert_raises(ValueError, get_data_field)
def test_conditional_on_non_integer_enum(): enum_test = [("instrument_type", b.enum(8, { 0: "pulse", 1: "wave", 2: "kit", 3: "noise" })), (b.CONDITIONAL, "instrument_type", { "pulse": [("pulse_foo", b.uint8)], "wave": [("wave_foo", b.uint8)], "kit": [("kit_foo", b.uint8)], "noise": [("noise_foo", b.uint8)] })] pulse_test = bytearray([0, 19]) pulse = b.parse(pulse_test, enum_test) assert_equal(pulse.instrument_type, "pulse") assert_equal(pulse.pulse_foo, 19) assert_equal(b.write(pulse, enum_test), pulse_test) wave_test = bytearray([1, 65]) wave = b.parse(wave_test, enum_test) assert_equal(wave.instrument_type, "wave") assert_equal(wave.wave_foo, 65) assert_equal(b.write(wave, enum_test), wave_test) kit_test = bytearray([2, 9]) kit = b.parse(kit_test, enum_test) assert_equal(kit.instrument_type, "kit") assert_equal(kit.kit_foo, 9) assert_equal(b.write(kit, enum_test), kit_test) noise_test = bytearray([3, 17]) noise = b.parse(noise_test, enum_test) assert_equal(noise.instrument_type, "noise") assert_equal(noise.noise_foo, 17) assert_equal(b.write(noise, enum_test), noise_test)
def test_conditional_on_non_integer_enum(): enum_test = [ ("instrument_type", b.enum(8, { 0: "pulse", 1: "wave", 2: "kit", 3: "noise" })), (b.CONDITIONAL, "instrument_type", { "pulse": [("pulse_foo", b.uint8)], "wave": [("wave_foo", b.uint8)], "kit": [("kit_foo", b.uint8)], "noise": [("noise_foo", b.uint8)] })] pulse_test = bytearray([0, 19]) pulse = b.parse(pulse_test, enum_test) assert pulse.instrument_type == "pulse" assert pulse.pulse_foo == 19 assert b.write(pulse, enum_test) == pulse_test wave_test = bytearray([1, 65]) wave = b.parse(wave_test, enum_test) assert wave.instrument_type == "wave" assert wave.wave_foo == 65 assert b.write(wave, enum_test) == wave_test kit_test = bytearray([2, 9]) kit = b.parse(kit_test, enum_test) assert kit.instrument_type == "kit" assert kit.kit_foo == 9 assert b.write(kit, enum_test) == kit_test noise_test = bytearray([3, 17]) noise = b.parse(noise_test, enum_test) assert noise.instrument_type == "noise" assert noise.noise_foo == 17 assert b.write(noise, enum_test) == noise_test
def test_read_modify_write_with_offset(): data = bytearray([4]) parsed = b.parse(data, offset_struct) assert parsed.length == 5 output = b.write(parsed, offset_struct) assert output == data parsed.length = 10 output = b.write(parsed, offset_struct) assert output[0] == 9
def test_conditional_on_non_integer_enum(): enum_test = [ ("instrument_type", b.enum(8, { 0: "pulse", 1: "wave", 2: "kit", 3: "noise" })), (b.CONDITIONAL, "instrument_type", { "pulse": [("pulse_foo", b.uint8)], "wave": [("wave_foo", b.uint8)], "kit": [("kit_foo", b.uint8)], "noise": [("noise_foo", b.uint8)] })] pulse_test = bytearray([0, 19]) pulse = b.parse(pulse_test, enum_test) assert_equal(pulse.instrument_type, "pulse") assert_equal(pulse.pulse_foo, 19) assert_equal(b.write(pulse, enum_test), pulse_test) wave_test = bytearray([1, 65]) wave = b.parse(wave_test, enum_test) assert_equal(wave.instrument_type, "wave") assert_equal(wave.wave_foo, 65) assert_equal(b.write(wave, enum_test), wave_test) kit_test = bytearray([2, 9]) kit = b.parse(kit_test, enum_test) assert_equal(kit.instrument_type, "kit") assert_equal(kit.kit_foo, 9) assert_equal(b.write(kit, enum_test), kit_test) noise_test = bytearray([3, 17]) noise = b.parse(noise_test, enum_test) assert_equal(noise.instrument_type, "noise") assert_equal(noise.noise_foo, 17) assert_equal(b.write(noise, enum_test), noise_test)
def test_read_modify_write_with_offset(): data = bytearray([4]) parsed = b.parse(data, offset_struct) assert_equal(parsed.length, 5) output = b.write(parsed, offset_struct) assert_equal(output, data) parsed.length = 10 output = b.write(parsed, offset_struct) assert_equal(output[0], 9)
def test_str_unicode(): str_test = [("msg", b.string(5))] data = bytearray([104, 101, 108, 108, 111]) result = b.parse(data, str_test) assert_equal(result.msg.decode('utf-8'), "hello") assert_equal(b.write(result, str_test), data) result.msg = "abate" output_data = b.write(result, str_test) edited_result = b.parse(output_data, str_test) assert_equal(result.msg, "abate")
def test_conditional_set(): true_data = bitstring.BitArray(bytearray([0b11001010, 0b11101000])) true_data.append('0b0') test_struct = b.parse(true_data, conditional_test) assert_equal(test_struct.frooz, 0b1001) assert_equal(test_struct.quxz, 0b01011101) assert_true(test_struct.qux) assert_false(hasattr(test_struct, "fooz")) assert_false(hasattr(test_struct, "barz")) test_struct.qux = False assert_false(test_struct.qux) assert_equal(test_struct.fooz, 0b10010101) assert_equal(test_struct.barz, 0b11010000) assert_false(hasattr(test_struct, "frooz")) assert_false(hasattr(test_struct, "quxz")) test_struct.barz = 0b11101010 written_bytes = b.write(test_struct) expected_bytes = bytearray([0b01001010, 0b11110101, 0b0]) assert_equal(written_bytes, expected_bytes)
def test_nested_array(): data = bytearray([42, 0, 1, 2, 3, 4, 5, 6, 7, 8, 0xdb]) nested_test = b.parse(data, nested_array_struct) assert_equal(nested_test.__offsets__.first, 0) assert_equal(nested_test.__offsets__.matrix, 8) assert_equal(nested_test.__offsets__.last, 80) assert_equal(len(nested_test), 88) assert_equal(nested_test.first, 42) for i in range(9): assert_equal(nested_test.matrix[int(i / 3)][int(i % 3)], i) assert_equal(nested_test.last, 0xdb) assert_equal(b.write(nested_test, nested_array_struct), data) expected_json_struct = { "first": 42, "matrix": [[0, 1, 2], [3, 4, 5], [6, 7, 8]], "last": 0xdb } assert_equal(json.loads(nested_test.as_json()), expected_json_struct)
def test_conditional_set(): true_data = bitstring.BitArray(bytearray([0b11001010, 0b11101000])) true_data.append('0b0') test_struct = b.parse(true_data, conditional_test) assert test_struct.frooz == 0b1001 assert test_struct.quxz == 0b01011101 assert test_struct.qux assert not hasattr(test_struct, "fooz") assert not hasattr(test_struct, "barz") test_struct.qux = False assert not test_struct.qux assert test_struct.fooz == 0b10010101 assert test_struct.barz == 0b11010000 assert not hasattr(test_struct, "frooz") assert not hasattr(test_struct, "quxz") test_struct.barz = 0b11101010 written_bytes = b.write(test_struct) expected_bytes = bytearray([0b01001010, 0b11110101, 0b0]) assert written_bytes == expected_bytes
def test_str_unicode(): str_test = [("msg", b.string(5))] data = bytearray([104, 101, 108, 108, 111]) result = b.parse(data, str_test) assert result.msg == "hello" assert b.write(result, str_test) == data result.msg = "abate" output_data = b.write(result, str_test) edited_result = b.parse(output_data, str_test) assert result.msg == "abate"
def save(self, filename): """Save a project in .lsdsng format to the target file. :param filename: the name of the file to which to save :deprecated: use ``save_lsdsng(filename)`` instead """ with open(filename, 'wb') as fp: writer = BlockWriter() factory = BlockFactory() preamble_dummy_bytes = bytearray([0] * 9) preamble = bread.parse( preamble_dummy_bytes, spec.lsdsng_preamble) preamble.name = self.name preamble.version = self.version preamble_data = bread.write(preamble) raw_data = self.get_raw_data() compressed_data = filepack.compress(raw_data) writer.write(compressed_data, factory) fp.write(preamble_data) for key in sorted(factory.blocks.keys()): fp.write(bytearray(factory.blocks[key].data))
def test_nested_array(): data = bytearray([42, 0, 1, 2, 3, 4, 5, 6, 7, 8, 0xdb]) nested_test = b.parse(data, nested_array_struct) assert nested_test.__offsets__.first == 0 assert nested_test.__offsets__.matrix == 8 assert nested_test.__offsets__.last == 80 assert len(nested_test) == 88 assert nested_test.first == 42 for i in xrange(9): assert nested_test.matrix[i / 3][i % 3] == i assert nested_test.last == 0xdb assert b.write(nested_test, nested_array_struct) == data expected_json_struct = { "first" : 42, "matrix" : [[0, 1, 2], [3, 4, 5], [6, 7, 8]], "last" : 0xdb } assert json.loads(nested_test.as_json()) == expected_json_struct
def test_nested_struct(): data = bitstring.BitArray(bytearray(range(34))) data.append('0b0') supernested_test = b.parse(data, deeply_nested_struct) assert_equal(supernested_test.__offsets__.ubermatrix, 0) assert_equal(supernested_test.__offsets__.dummy, 264) assert_equal(len(supernested_test), 273) assert_equal(len(supernested_test.ubermatrix), 3) assert_equal(sum(map(len, supernested_test.ubermatrix)), 264) current_byte = 0 for substruct in supernested_test.ubermatrix: assert_equal(substruct.first, current_byte) current_byte += 1 for i, j in itertools.product(range(3), range(3)): assert_equal(substruct.matrix[i][j], current_byte + i * 3 + j) current_byte += 9 assert_equal(substruct.last, current_byte) current_byte += 1 assert_equal(supernested_test.__offsets__.dummy, current_byte * 8) current_byte += 1 assert_equal(supernested_test.dummy.ok, False) assert_equal(b.write(supernested_test, deeply_nested_struct), bytearray(list(range(34)) + [0b0])) expected_json_struct = { "dummy": { "length": 33, "ok": False }, "ubermatrix": [ { "first": 0, "matrix": [[1, 2, 3], [4, 5, 6], [7, 8, 9]], "last": 10 }, { "first": 11, "matrix": [[12, 13, 14], [15, 16, 17], [18, 19, 20]], "last": 21 }, { "first": 22, "matrix": [[23, 24, 25], [26, 27, 28], [29, 30, 31]], "last": 32 } ] } assert_equal(json.loads(supernested_test.as_json()), expected_json_struct)
def test_str(): str_test = [("msg", b.string(5))] data = bytearray([0x68, 0x65, 0x6c, 0x6c, 0x6f]) result = b.parse(data, str_test) assert_equal(result.msg.decode('utf-8'), "hello") assert_equal(b.write(result, str_test), data)
def save_srm(self, filename): """Save a project in .srm format to the target file. :param filename: the name of the file to which to save """ with open(filename, 'wb') as fp: raw_data = bread.write(self._song_data, spec.song) fp.write(raw_data)
def test_file_io(): data = bytearray(list(range(36))) supernested_test = b.parse(data, deeply_nested_struct) (handle, file_path) = tempfile.mkstemp() try: b.write(supernested_test, deeply_nested_struct, filename=file_path) with open(file_path, 'rb') as fp: supernested_test_from_file = b.parse(fp, deeply_nested_struct) for i, j, k in itertools.product(range(3), range(3), range(3)): assert supernested_test_from_file.ubermatrix[i].matrix[j][k] == supernested_test.ubermatrix[i].matrix[j][k] finally: os.close(handle) os.unlink(file_path)
def test_nested_struct(): data = bytearray(range(36)) supernested_test = b.parse(data, deeply_nested_struct) assert supernested_test.__offsets__.ubermatrix == 0 assert supernested_test.__offsets__.dummy == 264 assert len(supernested_test) == 273 assert len(supernested_test.ubermatrix) == 3 current_byte = 0 for substruct in supernested_test.ubermatrix: assert substruct.first == current_byte current_byte += 1 for i, j in itertools.product(xrange(3), xrange(3)): assert substruct.matrix[i][j] == current_byte + i * 3 + j current_byte += 9 assert substruct.last == current_byte current_byte += 1 assert supernested_test.dummy.length == current_byte current_byte += 1 assert supernested_test.dummy.ok == False assert (b.write(supernested_test, deeply_nested_struct) == bytearray(range(34) + [0b0])) expected_json_struct = { "dummy" : { "length" : 33, "ok" : False }, "ubermatrix" : [ { "first" : 0, "matrix": [[1, 2, 3], [4, 5, 6], [7, 8, 9]], "last" : 10 }, { "first" : 11, "matrix": [[12, 13, 14], [15, 16, 17], [18, 19, 20]], "last" : 21 }, { "first" : 22, "matrix": [[23, 24, 25], [26, 27, 28], [29, 30, 31]], "last" : 32 } ] } assert json.loads(supernested_test.as_json()) == expected_json_struct
def test_str(): str_test = [("msg", b.string(5))] data = bytearray([0x68, 0x65, 0x6c, 0x6c, 0x6f]) result = b.parse(data, str_test) assert result.msg == "hello" assert b.write(result, str_test) == data
def test_str(): str_test = [("msg", b.string(5))] data = bytearray([0x68, 0x65, 0x6c, 0x6c, 0x6f]) result = b.parse(data, str_test) assert result.msg == "hello" assert b.write(result, str_test) == data assert result.as_json() == json.dumps({'msg': 'hello'})
def test_file_io(): data = bytearray(list(range(36))) supernested_test = b.parse(data, deeply_nested_struct) (handle, file_path) = tempfile.mkstemp() try: b.write(supernested_test, deeply_nested_struct, filename=file_path) with open(file_path, 'rb') as fp: supernested_test_from_file = b.parse(fp, deeply_nested_struct) for i, j, k in itertools.product(range(3), range(3), range(3)): assert_equal(supernested_test_from_file.ubermatrix[i].matrix[j][k], supernested_test.ubermatrix[i].matrix[j][k]) finally: os.close(handle) os.unlink(file_path)
def test_nested_struct(): data = bitstring.BitArray(bytearray(range(34))) data.append('0b0') supernested_test = b.parse(data, deeply_nested_struct) assert_equal(supernested_test.__offsets__.ubermatrix, 0) assert_equal(supernested_test.__offsets__.dummy, 264) assert_equal(len(supernested_test), 273) assert_equal(len(supernested_test.ubermatrix), 3) assert_equal(sum(map(len, supernested_test.ubermatrix)), 264) current_byte = 0 for substruct in supernested_test.ubermatrix: assert_equal(substruct.first, current_byte) current_byte += 1 for i, j in itertools.product(range(3), range(3)): assert_equal(substruct.matrix[i][j], current_byte + i * 3 + j) current_byte += 9 assert_equal(substruct.last, current_byte) current_byte += 1 assert_equal(supernested_test.__offsets__.dummy, current_byte * 8) current_byte += 1 assert_equal(supernested_test.dummy.ok, False) assert_equal(b.write(supernested_test, deeply_nested_struct), bytearray(list(range(34)) + [0b0])) expected_json_struct = { "dummy": { "length": 33, "ok": False }, "ubermatrix": [{ "first": 0, "matrix": [[1, 2, 3], [4, 5, 6], [7, 8, 9]], "last": 10 }, { "first": 11, "matrix": [[12, 13, 14], [15, 16, 17], [18, 19, 20]], "last": 21 }, { "first": 22, "matrix": [[23, 24, 25], [26, 27, 28], [29, 30, 31]], "last": 32 }] } assert_equal(json.loads(supernested_test.as_json()), expected_json_struct)
def test_set_array_to_list(): data = bytearray([42, 0, 1, 2, 3, 4, 5, 6, 7, 8, 0xdb]) nested_test = b.parse(data, nested_array_struct) nested_test.matrix = [[2, 4, 6], [8, 10, 12], [14, 16, 18]] output_bytes = b.write(nested_test) assert output_bytes == bytearray([42, 2, 4, 6, 8, 10, 12, 14, 16, 18, 0xdb]) nested_test.matrix[1] = [9, 8, 7] output_bytes = b.write(nested_test) assert output_bytes == bytearray([42, 2, 4, 6, 9, 8, 7, 14, 16, 18, 0xdb]) def assign_wrong_length_array(): nested_test.matrix[1] = [9, 8, 7, 6] with pytest.raises(ValueError): assign_wrong_length_array()
def test_set_array_to_list(): data = bytearray([42, 0, 1, 2, 3, 4, 5, 6, 7, 8, 0xdb]) nested_test = b.parse(data, nested_array_struct) nested_test.matrix = [[2, 4, 6], [8, 10, 12], [14, 16, 18]] output_bytes = b.write(nested_test) assert_equal(output_bytes, bytearray([42, 2, 4, 6, 8, 10, 12, 14, 16, 18, 0xdb])) nested_test.matrix[1] = [9, 8, 7] output_bytes = b.write(nested_test) assert_equal(output_bytes, bytearray([42, 2, 4, 6, 9, 8, 7, 14, 16, 18, 0xdb])) def assign_wrong_length_array(): nested_test.matrix[1] = [9, 8, 7, 6] assert_raises(ValueError, assign_wrong_length_array)
def test_read_and_write_prefix(): lsdsng_preamble = [("name", b.string(8)), ("version", b.byte)] data = 'hellomon'.encode('utf-8') data += bytearray([10, 20, 30, 40, 50]) parsed = b.parse(data, lsdsng_preamble) assert_equal(len(parsed), 9 * 8) output_bytes = b.write(parsed) assert_equal(len(output_bytes), 9)
def test_read_modify_write(): data = bytearray(range(36)) supernested_test = b.parse(data, deeply_nested_struct) assert supernested_test.ubermatrix[1].matrix[2][1] == 19 supernested_test.ubermatrix[1].matrix[2][1] = 42 written_data = b.write(supernested_test, deeply_nested_struct) re_read_data = b.parse(written_data, deeply_nested_struct) assert re_read_data.ubermatrix[1].matrix[2][1] == 42
def test_set_sub_byte_intX(): test_struct = [("signed_nibble", b.intX(4, signed=True)), ("bit1", b.bit), ("bit2", b.bit), ("seminibble", b.semi_nibble)] test_data = bytearray([0xdb]) test_parsed = b.parse(test_data, test_struct) assert_equal(test_parsed.signed_nibble, -3) test_parsed.signed_nibble = -6 test_parsed.bit1 = 0 test_parsed.seminibble = 2 assert_equal(bytearray([0xa2]), b.write(test_parsed))
def test_endianness(): endianness_test = [ ("big_endian", b.uint32, {"endianness": b.BIG_ENDIAN}), ("little_endian", b.uint32, {"endianness": b.LITTLE_ENDIAN}), ("default_endian", b.uint32)] data = bytearray([0x01, 0x02, 0x03, 0x04] * 3) test = b.parse(data, endianness_test) assert_equal(test.big_endian, 0x01020304) assert_equal(test.little_endian, 0x04030201) assert_equal(hex(test.default_endian), hex(test.little_endian)) assert_equal(b.write(test, endianness_test), data)
def test_new(): format_spec = [("greeting", b.string(5)), ("age", b.nibble)] empty_struct = b.new(format_spec) assert_equal(len(empty_struct), 8 * 5 + 4) assert_equal(empty_struct.greeting, b'\x00\x00\x00\x00\x00') assert_equal(empty_struct.age, 0) empty_struct.greeting = 'hello' empty_struct.age = 0xb output_bytes = b.write(empty_struct) assert_equal(output_bytes, bytearray([0x68, 0x65, 0x6c, 0x6c, 0x6f, 0xb0]))
def test_single_byte_fields(): single_byte_fields_struct = [("bit_0", b.bit), ("bit_1", b.bit), ("semi_nibble", b.semi_nibble), ("nibble", b.nibble)] data = bytearray([0b10110010]) test = b.parse(data, single_byte_fields_struct) assert_equal(test.bit_0, 1) assert_equal(test.bit_1, 0) assert_equal(test.semi_nibble, 0b11) assert_equal(test.nibble, 0b0010) assert_equal(b.write(test, single_byte_fields_struct), data)
def dump(sysex_json: Union[dict, list]) -> bytes: if type(sysex_json) == dict: # Single voice single_voice_blank_data = bytearray(SINGLE_VOICE_SYSEX_LENGTH) single_voice_blank_data[1] = 0 sysex = bread.new(sysex_dump_message, data=single_voice_blank_data) sysex.format_number = 0 sysex.byte_count = 0x011b load_parsed_voice_into_struct(cast(dict, sysex_json), sysex) else: multivoice_blank_data = bytearray(MULTI_VOICE_SYSEX_LENGTH) multivoice_blank_data[1] = 9 sysex = bread.new(sysex_dump_message, data=multivoice_blank_data) sysex.format_number = 9 sysex.byte_count = 0x2000 for i, voice in enumerate(sysex_json): load_parsed_voice_into_struct(sysex_json[i], sysex.voices[i]) parsed_data = bread.write(sysex, sysex_dump_message) sysex.checksum = compute_checksum(parsed_data) return bread.write(sysex, sysex_dump_message)
def test_endianness(): endianness_test = [ ("big_endian", b.uint32, {"endianness" : b.BIG_ENDIAN}), ("little_endian", b.uint32, {"endianness" : b.LITTLE_ENDIAN}), ("default_endian", b.uint32)] data = bytearray([0x01, 0x02, 0x03, 0x04] * 3) test = b.parse(data, endianness_test) assert test.big_endian == 0x01020304 assert test.little_endian == 0x04030201 assert test.default_endian == test.little_endian assert b.write(test, endianness_test) == data
def test_read_modify_write(): data = bitstring.BitArray(bytearray(range(34))) data.append('0b0') supernested_test = b.parse(data, deeply_nested_struct) assert_equal(supernested_test.ubermatrix[1].matrix[2][1], 19) supernested_test.ubermatrix[1].matrix[2][1] = 42 assert_equal(supernested_test.ubermatrix[1].matrix[2][1], 42) written_data = b.write(supernested_test, deeply_nested_struct) re_read_data = b.parse(written_data, deeply_nested_struct) assert_equal(re_read_data.ubermatrix[1].matrix[2][1], 42)
def test_array(): data = bytearray([0b11111111, 0b10010101, 0b00010001]) array_test = b.parse(data, test_array_struct) assert_equal(array_test.__offsets__.first, 0) assert_equal(array_test.__offsets__.flags, 8) assert_equal(array_test.__offsets__.last, 16) assert_equal(len(array_test), 24) expected_flags = [True, False, False, True, False, True, False, True] assert_equal(array_test.flags, expected_flags) assert_equal(b.write(array_test, test_array_struct), data)
def test_endianness(): endianness_test = [("big_endian", b.uint32, { "endianness": b.BIG_ENDIAN }), ("little_endian", b.uint32, { "endianness": b.LITTLE_ENDIAN }), ("default_endian", b.uint32)] data = bytearray([0x01, 0x02, 0x03, 0x04] * 3) test = b.parse(data, endianness_test) assert_equal(test.big_endian, 0x01020304) assert_equal(test.little_endian, 0x04030201) assert_equal(hex(test.default_endian), hex(test.little_endian)) assert_equal(b.write(test, endianness_test), data)
def test_simple_struct(): data = struct.pack(">IqQb", 0xafb0dddd, -57, 90, 0) test = b.parse(data, spec=test_struct) assert_equal(test.__offsets__.flag_one, 0) assert_equal(test.__offsets__.flag_two, 1) assert_equal(test.__offsets__.flag_three, 2) assert_equal(test.__offsets__.flag_four, 3) assert_equal(test.__offsets__.first, 4) assert_equal(test.__offsets__.blah, 16) assert_equal(test.__offsets__.second, 32) assert_equal(test.__offsets__.third, 96) assert_equal(test.__offsets__.fourth, 160) assert_equal(len(test), 168) assert_equal(test.flag_one, True) assert_equal(test.flag_two, False) assert_equal(test.flag_three, True) assert_equal(test.flag_four, False) assert_equal(test.first, 0xfb) assert_equal(test.blah, 0xdddd) assert_equal(test.second, -57) assert_equal(test.third, 90) assert_equal(test.fourth, 0) output_data = b.write(test, test_struct) assert_equal(output_data, data) expected_json_struct = { "flag_one": True, "flag_two": False, "flag_three": True, "flag_four": False, "first": 0xfb, "blah": 0xdddd, "second": -57, "third": 90, "fourth": 0 } assert_equal(json.loads(test.as_json()), expected_json_struct)
def test_write_intX(): ints_struct = [("off_by_one", b.uint8, { "offset": 1 }), ("unsigned_int", b.uint16), ("signed_int", b.int8)] data = bytearray([5, 0xba, 0xbd, 0xed]) parsed = b.parse(data, ints_struct) assert_equal(parsed.off_by_one, 6) assert_equal(parsed.unsigned_int, 0xbdba) assert_equal(parsed.signed_int, -19) parsed.off_by_one = 9 parsed.unsigned_int = 0xcbab parsed.signed_int = -7 output = b.write(parsed) assert_equal(output, bytearray([8, 0xab, 0xcb, 0xf9]))
def test_non_powers_of_eight_intX(): intX_test = [ ("unsigned_10b", b.intX(10, False)), ("unsigned_14b", b.intX(14, False)), ("signed_20b", b.intX(20, True)), ("signed_4b", b.intX(4, True)), ] in_bytes = bytearray([ 0b11010101, 0b11101010, 0b00110101, 0b11010101, 0b11101010, 0b00110101 ]) result = b.parse(in_bytes, intX_test) assert_equal(result.unsigned_10b, 0b1101010111) assert_equal(result.unsigned_14b, 0b10101000110101) assert_equal(result.signed_20b, -0b101010000101011101) assert_equal(result.signed_4b, 0b0101) assert_equal(b.write(result, intX_test), in_bytes)
def test_instrument_sizes(): instr_bytes = list(filepack.DEFAULT_INSTRUMENT) parsed = b.parse(instr_bytes, bread_spec.instrument) assert_equal(len(parsed), 16 * 8) raw_data = b.write(parsed, bread_spec.instrument) assert_bytearray_equal(raw_data, bytearray(filepack.DEFAULT_INSTRUMENT)) instr_bytes[0] = 1 parsed = b.parse(instr_bytes, bread_spec.instrument) assert_equal(len(parsed), 16 * 8) instr_bytes[0] = 2 parsed = b.parse(instr_bytes, bread_spec.instrument) assert_equal(len(parsed), 16 * 8) instr_bytes[0] = 3 parsed = b.parse(instr_bytes, bread_spec.instrument) assert_equal(len(parsed), 16 * 8)
def test_write_non_obj(): b.write("piiiineapples!")
def _save(self, fp, callback): # Marshal 32 possible projects + write preamble + write data + "all # done" total_steps = 35 current_step = 0 writer = BlockWriter() factory = BlockFactory() # Block allocation table doesn't include header block because it's # always in use, so have to add additional block to account for header num_blocks = self.BAT_END_OFFSET - self.BAT_START_OFFSET + 2 header_block = factory.new_block() block_table = [] for i in range(num_blocks): block_table.append(None) # First block is the header block, so we should ignore it when creating # the block allocation table block_table[0] = -1 for i in range(NUM_FILES): project = self.projects[i] current_step += 1 if project is None: continue callback("Marshaling song '%s'" % (utils.name_without_zeroes(project.name)), current_step - 1, total_steps, True) raw_data = project.get_raw_data() compressed_data = filepack.compress(raw_data) project_block_ids = writer.write(compressed_data, factory) for b in project_block_ids: block_table[b] = i callback("Writing preamble and constructing header block", current_step, total_steps, True) current_step += 1 # Bytes up to START_OFFSET will remain the same fp.write(self.preamble) # Set header block filenames and versions empty_project_name = '\0' * self.FILENAME_LENGTH for i in range(NUM_FILES): project = self.projects[i] if project is None: self.header_block.filenames[i] = empty_project_name self.header_block.file_versions[i] = 0 else: self.header_block.filenames[i] = project.name self.header_block.file_versions[i] = project.version self.header_block.active_file = self.active_project_number # Ignore the header block when serializing the block allocation table for i, b in enumerate(block_table[1:]): if b is None: file_no = EMPTY_BLOCK else: file_no = b self.header_block.block_alloc_table[i] = file_no header_block.data = bread.write( self.header_block, bread_spec.compressed_sav_file) assert len(header_block.data) == blockutils.BLOCK_SIZE, \ "Header block isn't the expected length; expected 0x%x, got 0x%x" \ % (blockutils.BLOCK_SIZE, len(header_block.data)) block_map = factory.blocks empty_block_data = [] for i in range(blockutils.BLOCK_SIZE): empty_block_data.append(0) callback("Writing data to file", current_step, total_steps, True) current_step += 1 for i in range(num_blocks): if i in block_map: data_list = block_map[i].data else: data_list = empty_block_data fp.write(bytearray(data_list)) callback("Save complete!", total_steps, total_steps, True)