def test_s1(self):
s = self.segment
s.set_comment([[4,5]], "test1")
s.set_comment([[40,50]], "test2")
s.set_style_ranges([[2,100]], comment=True)
s.set_style_ranges([[200, 299]], data=True)
for i in range(1,4):
for j in range(1, 4):
# create some with overlapping regions, some without
r = [500*j, 500*j + 200*i + 200]
s.set_style_ranges([r], user=i)
s.set_user_data([r], i, i*10 + j)
r = [100, 200]
s.set_style_ranges([r], user=4)
s.set_user_data([r], 4, 99)
r = [3100, 3200]
s.set_style_ranges([r], user=4)
s.set_user_data([r], 4, 99)
out = dict()
s.serialize_extra_to_dict(out)
print "saved", out
data = np.ones([4000], dtype=np.uint8)
r = SegmentData(data)
s2 = DefaultSegment(r, 0)
s2.restore_extra_from_dict(out)
out2 = dict()
s2.serialize_extra_to_dict(out2)
print "loaded", out2
assert out == out2
def test_short_segment(self):
bytes = [0xff, 0xff, 0x00, 0x60, 0xff, 0x60, 1, 2]
rawdata = SegmentData(bytes)
image = AtariDosFile(rawdata)
image.parse_segments()
assert len(image.segments) == 1
assert len(image.segments[0]) == 2
def test_unbanked(self, k_size, cart_type):
data = self.get_cart(k_size, cart_type)
rawdata = SegmentData(data)
image = AtariCartImage(rawdata, cart_type)
image.parse_segments()
assert len(image.segments) == 2
assert len(image.segments[0]) == 16
assert len(image.segments[1]) == k_size * 1024
def test_bad(self):
k_size = 32
# check for error because invalid data in cart image itself
data = self.get_cart(k_size, 1337)
rawdata = SegmentData(data)
with pytest.raises(errors.InvalidDiskImage):
image = AtariCartImage(rawdata, 1337)
with pytest.raises(errors.InvalidDiskImage):
image = AtariCartImage(rawdata, 12)
# check for error with valid cart image, but invalid cart type supplied
# to the image parser
data = self.get_cart(k_size, 12)
rawdata = SegmentData(data)
with pytest.raises(errors.InvalidDiskImage):
image = AtariCartImage(rawdata, 1337)
def test_typical_rom_sizes(self, k_size):
data = self.get_rom(k_size)
rawdata = SegmentData(data)
rom_image = RomImage(rawdata)
rom_image.strict_check()
rom_image.parse_segments()
assert len(rom_image.segments) == 1
assert len(rom_image.segments[0]) == k_size * 1024
def identify(self, guess):
r = SegmentData(guess.numpy)
try:
parser = Atari800Parser(r)
except errors.InvalidSegmentParser:
return
guess.parser = parser
return self.id
def get_bytes(self, dlg):
xex = dlg.get_bytes()
title, author = dlg.get_extra_text()[0:2]
byte_values = add_xexboot_header(xex, title=title, author=author)
byte_values = add_atr_header(byte_values)
rawdata = SegmentData(byte_values)
atr = BootDiskImage(rawdata)
return atr.raw_bytes.tobytes()
def setup(self):
self.screen = np.zeros(40 * 90, dtype=np.uint8)
data = np.fromstring(
"\x04\x00\x00\x01\x01\x01\x01\x04\x00\x01\x01\x00\x01\x00\x04\x00\x02\x01\x01\x01\x01\xff\x04\x00\x00\x00\x00\x00\x00\x04\x00\x01\x00\x00\x00\x00\x04\x00\x02\x00\x00\x00\x00\xff\x02\x00\x00\x02\x02\x02\x06\x00\x02\x02\x02\x00\x01\x02\x02\x02\x06\x01\x02\x02\x08\x00\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02\x00\x03\x02\x02\x02\x06\x03\x02\x02\xff\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\xff\x04\x00\x00\x00\x03\x03\x00\x04\x00\x01\x03\x00\x00\x03\x04\x00\x02\x00\x03\x03\x00\xff\x04\x00\x00\x00\x00\x00\x00\x04\x00\x01\x00\x00\x00\x00\x04\x00\x02\x00\x00\x00\x00\xff\x01\x00\x00\x01\x01\x01\x01\x01\x01\x00\x02\x01\x01\x01\x03\x01\xff\x01\x00\x00\x02\x01\x00\x01\x02\x01\x01\x02\x02\x01\x01\x03\x02\xff\x02\x00\x00\x00\x00\x02\x00\x01\x00\x00\x02\x00\x02\x00\x00\x02\x00\x03\x00\x00\xff",
dtype=np.uint8)
r = SegmentData(data)
segments = [DefaultSegment(r, 0x4000)]
self.builder = JumpmanLevelBuilder(segments)
def __init__(self, parent, task, bytes_per_row=16, command=None, **kwargs):
FontMapScroller.__init__(self, parent, task, bytes_per_row, command,
**kwargs)
self.char_order = DefaultSegment(
SegmentData(np.arange(256, dtype=np.uint8),
np.zeros(256, dtype=np.uint8)), 0)
self.start_addr = 0
self.selected_char = -1
def identify(self, guess):
r = SegmentData(guess.numpy)
try:
mime, parser = iter_parsers(r)
except errors.UnsupportedDiskImage:
parser = None
if parser is not None:
guess.parser = parser
return mime
def test_banked(self, k_size, main_size, banked_size, cart_type):
data = self.get_cart(k_size, cart_type)
rawdata = SegmentData(data)
image = AtariCartImage(rawdata, cart_type)
image.parse_segments()
assert len(
image.segments) == 1 + 1 + (k_size - main_size) // banked_size
assert len(image.segments[0]) == 16
assert len(image.segments[1]) == main_size * 1024
assert len(image.segments[2]) == banked_size * 1024
def parse_segments(self, parser_list):
parser_list.append(DefaultSegmentParser)
r = SegmentData(self.raw_bytes, self.style)
for parser in parser_list:
try:
s = parser(r)
break
except errors.InvalidSegmentParser:
pass
self.set_segments(s)
def get_break(self, section_break):
data = np.empty(32, dtype=np.uint8)
data[0:section_break] = 0x8d
data[section_break:] = 0xfc
style = np.empty(32, dtype=np.uint8)
style[0:section_break] = 0
style[section_break:] = 1
raw = SegmentData(data, style)
segment = DefaultSegment(raw, 0)
return segment
def test_container(self, ext):
pathname = self.base_path + ext
try:
sample_data = np.fromfile(pathname, dtype=np.uint8)
except OSError:
pass
else:
rawdata = SegmentData(sample_data.copy())
mime, parser = iter_parsers(rawdata)
assert mime == self.expected_mime
assert len(parser.image.files) == self.num_files_in_sample
def setup(self):
data = np.arange(256, dtype=np.uint8)
style = np.zeros(256, dtype=np.uint8)
raw = SegmentData(data, style)
s = DefaultSegment(raw, 0)
s.set_style_ranges([(10,20),], data=True)
s.set_style_ranges([(30,40),], user=1)
s.set_comment([(0,5)], "comment 0-5")
s.set_comment([(15,16)], "comment 15-16")
s.set_comment([(18,24)], "comment 18,24")
s.set_comment([(38,42)], "comment 38,42")
s.set_comment([(51,55)], "comment 51,55")
self.editor = MockHexEditor(segment=s)
def __init__(self, parent, id, title):
wx.Frame.__init__(self, parent, id, title, wx.DefaultPosition,
wx.DefaultSize)
data = np.arange(0x800, dtype=np.uint8)
data[0:0x50] = np.fromstring(
"01\x1b1\x1b1\x1b1\xa0I\xc6\x94\xaax\x0f\x00\x00B\x80E\x1b1\xe00:\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00Ws\x8e\xab\x00\x00\x86\x86\x0fT\x86\x8a\xff\xca\x00d\x00\xd0\x07\x00,F,\x80(\x01\x10L\xfdO!\x00\x00L\x00\x00 K(`\xff\x00\x8e,",
dtype=np.uint8)
data[0x3ec:0x400] = np.fromstring("abdceabdceabcdeabcde",
dtype=np.uint8)
r = SegmentData(data)
segment = DefaultSegment(r, 0x2800)
editor = MockEditor(segment)
task = MockTask(editor)
self.info = InfoPanel(self, task, fields)
self.info.recalc_view()
def test_bad(self):
data = np.fromstring("\x8dp0L\xaa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00pppM\x00p\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\x8d\x8d\x06\x16\x8e\r", dtype=np.uint8)
style = np.empty(len(data), dtype=np.uint8)
style[0:17] = 0
style[17:] = 2
raw = SegmentData(data, style)
s = DefaultSegment(raw, 0x3bef)
info = self.disasm.disassemble_segment(s)
inst = info.instructions
for i in range(info.num_instructions):
print(info[i].instruction)
text = self.disasm.get_disassembled_text()
print("\n".join(text))
text = self.disasm.get_atasm_lst_text()
print("\n".join(text))
def get_exe_segments(self):
data1 = np.arange(4096, dtype=np.uint8)
data1[1::2] = np.repeat(np.arange(16, dtype=np.uint8), 128)
data2 = np.arange(4096, dtype=np.uint8)
data2[0::4] = np.repeat(np.arange(8, dtype=np.uint8), 128)
raw = [
(data1, 0x4000),
(data2, 0x8000),
]
segments = []
for data, origin in raw:
rawdata = SegmentData(data)
s = DefaultSegment(rawdata, origin)
segments.append(s)
return segments
def test_unbanked(self):
carts = [
(8, 1),
(16, 2),
(8, 21),
(2, 57),
(4, 58),
(4, 59),
]
for k_size, cart_type in carts:
data = self.get_cart(k_size, cart_type)
rawdata = SegmentData(data)
image = AtariCartImage(rawdata, cart_type)
image.parse_segments()
assert len(image.segments) == 2
assert len(image.segments[0]) == 16
assert len(image.segments[1]) == k_size * 1024
def check_size(self, data):
xex_size = len(data)
bytes = add_xexboot_header(data)
# rawdata = SegmentData(bytes)
# size = len(rawdata)
# atr = KBootImage(rawdata)
# newatr = atr.as_new_format("ATR")
image_size = len(bytes)
bytes = add_atr_header(bytes)
rawdata = SegmentData(bytes)
newatr = KBootImage(rawdata)
image = newatr.bytes
print image[0:16]
paragraphs = image_size / 16
print newatr.header, paragraphs
assert int(image[2:4].view(dtype='<u2')) == paragraphs
assert int(image[16 + 9:16 + 9 + 2].view('<u2')) == xex_size
return image
def test_banked(self):
carts = [
(32, 8, 8, 12),
(64, 8, 8, 13),
(64, 8, 8, 67),
(128, 8, 8, 14),
(256, 8, 8, 23),
(512, 8, 8, 24),
(1024, 8, 8, 25),
]
for k_size, main_size, banked_size, cart_type in carts:
data = self.get_cart(k_size, cart_type)
rawdata = SegmentData(data)
image = AtariCartImage(rawdata, cart_type)
image.parse_segments()
assert len(image.segments) == 1 + 1 + (k_size - main_size)/banked_size
assert len(image.segments[0]) == 16
assert len(image.segments[1]) == main_size * 1024
assert len(image.segments[2]) == banked_size * 1024
def test_segment(self):
bytes = np.asarray([0xff, 0xff, 0x00, 0x60, 0x01, 0x60, 1, 2],
dtype=np.uint8)
rawdata = SegmentData(bytes)
container = XexContainerSegment(rawdata, 0)
image = AtariDosFile(container.rawdata)
image.parse_segments()
print(image.segments)
assert len(image.segments) == 1
assert len(image.segments[0]) == 2
assert np.all(image.segments[0] == bytes[6:8])
container.resize(16)
for s in image.segments:
s.replace_data(container)
new_segment = DefaultSegment(rawdata[8:16])
new_segment[:] = 99
assert np.all(image.segments[0] == bytes[6:8])
print(new_segment[:])
assert np.all(new_segment[:] == 99)
def test_conversion_to_atari_cart(self, cart):
cart_type = cart[0]
name = cart[1]
k_size = cart[2]
if "Bounty" in name:
return
data = self.get_rom(k_size)
rawdata = SegmentData(data)
rom_image = RomImage(rawdata)
rom_image.strict_check()
rom_image.parse_segments()
new_cart_image = AtariCartImage(rawdata, cart_type)
new_cart_image.relaxed_check()
new_cart_image.parse_segments()
assert new_cart_image.header.valid
s = new_cart_image.create_emulator_boot_segment()
assert len(s) == len(rawdata) + new_cart_image.header.nominal_length
assert s[0:4].tobytes() == b'CART'
assert s[4:8].view(dtype=">u4") == cart_type
def setup(self):
self.segments = []
for i in range(8):
data = np.ones([1024], dtype=np.uint8) * i
r = SegmentData(data)
self.segments.append(DefaultSegment(r, i * 1024))
def setup(self):
data = np.arange(32, dtype=np.uint8)
style = np.zeros(32, dtype=np.uint8)
raw = SegmentData(data, style)
segment = DefaultSegment(raw, 0)
self.editor = MockHexEditor(segment=segment)
def _segments_default(self):
r = SegmentData(self.raw_bytes,self.style)
return list([DefaultSegment(r, 0)])
def test_invalid_rom_sizes(self, k_size):
data = np.zeros((k_size * 1024) + 17, dtype=np.uint8)
rawdata = SegmentData(data)
with pytest.raises(errors.InvalidDiskImage):
rom_image = RomImage(rawdata)
def setup(self):
data = np.arange(4096, dtype=np.uint8)
data[1::2] = np.repeat(np.arange(16, dtype=np.uint8), 128)
r = SegmentData(data)
self.segment = DefaultSegment(r, 0)
def test_err_segment(self):
bytes = [0xff, 0xff, 0x00, 0x60, 0x00, 0x00, 1, 2]
rawdata = SegmentData(bytes)
image = AtariDosFile(rawdata)
with pytest.raises(errors.InvalidBinaryFile):
image.parse_segments()
assert grid_color_indexes.shape == grid_style.shape
assert grid_color_indexes.shape == (grid_height, pixels_per_row)
rgb_image = pc.calc_rgb_from_color_indexes_python(
grid_color_indexes, grid_style, color_list, empty_rgb)
assert rgb_image.shape == (grid_height, pixels_per_row, 3)
fast_rgb_image = fast_pc.calc_rgb_from_color_indexes(
grid_color_indexes, grid_style, color_list, empty_rgb)
assert (np.array_equal(rgb_image, fast_rgb_image))
if __name__ == "__main__":
data = np.arange(64, dtype=np.uint8)
style = np.zeros(64, dtype=np.uint8)
raw = SegmentData(data, style)
segment = DefaultSegment(raw, 0)
print(data)
ppb = 8
pixels_per_row = 16
bytes_per_row = pixels_per_row // ppb
c = pc.Converter1bpp()
grid_color_indexes, grid_style = c.calc_color_index_grid(
data, style, bytes_per_row)
print(grid_color_indexes)
ppb = 4
pixels_per_row = 16
bytes_per_row = pixels_per_row // ppb
c = pc.Converter2bpp()