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_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 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 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_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_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_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 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_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_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_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_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_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)
