mirror of
https://github.com/Virtual-World-RE/NeoGF.git
synced 2025-10-31 21:40:31 +01:00
1248 lines
66 KiB
Python
1248 lines
66 KiB
Python
from doltool import Dol, MemoryObject, Section, ActionReplayCode
|
|
from doltool import SectionType, IntervalDiv
|
|
from doltool import InvalidImgOffsetError, InvalidVirtualAddressError, InvalidIniFileEntryError, OutOfMemoryError, InvalidSectionAlignError, SectionsOverflowError
|
|
from doltool import parse_action_replay_ini, get_overlapping_arcodes, get_unmapped_intervals
|
|
|
|
import copy
|
|
import os
|
|
from pathlib import Path
|
|
import shutil
|
|
from time import time
|
|
|
|
|
|
__version__ = "0.0.4"
|
|
__author__ = "rigodron, algoflash, GGLinnk"
|
|
__license__ = "MIT"
|
|
__status__ = "developpement"
|
|
|
|
|
|
##################################################
|
|
# Installation
|
|
##################################################
|
|
# Original Gotcha Force "eu.dol" has to be placed in the same folder than this script.
|
|
##################################################
|
|
# Path of test folder
|
|
##################################################
|
|
# Dols samples path
|
|
dols_path = Path("dol_samples")
|
|
# Inis path
|
|
ini_path = Path("ini_tests")
|
|
# Used to create dols.
|
|
dol_tests_path = Path("dol_tests")
|
|
# Dols parsed and rebuild path
|
|
dols_save_path = Path("dol_save")
|
|
|
|
##################################################
|
|
# doltool.py commands wrappers
|
|
##################################################
|
|
def doltool_par(dol_path:Path, output_path:Path, ini_path:Path):
|
|
if os.system(f"python doltool.py -par \"{dol_path}\" -o \"{output_path}\" -ini \"{ini_path}\"") != 0:
|
|
raise Exception("Error while patching dol using ARCodes ini file.")
|
|
def doltool_par_sr(dol_path:Path, output_path:Path, ini_path:Path):
|
|
if os.system(f"python doltool.py -par \"{dol_path}\" -o \"{output_path}\" -ini \"{ini_path}\" -sr\"") != 0:
|
|
raise Exception("Error while patching dol using ARCodes ini file and section remapping.")
|
|
|
|
##################################################
|
|
# Helpers
|
|
##################################################
|
|
class DolDescriptor:
|
|
def __init__(self, index:int, offset:int, address:int, length:int, byte:bytes):
|
|
self.index = index
|
|
self.offset = offset + 0x100
|
|
self.address = address
|
|
self.length = length
|
|
self.byte = byte
|
|
def boffset(self): return self.offset.to_bytes(4,"big")
|
|
def baddress(self): return (self.address + 0x80003100).to_bytes(4,"big")
|
|
def blength(self): return self.length.to_bytes(4,"big")
|
|
|
|
|
|
def map_offsets(datas:bytes, offsets_map:list, intervals:list):
|
|
'create virtual space temporary to patch then replace as initial mapped with patched datas.'
|
|
max_address = 0
|
|
for beg,length,dest in offsets_map:
|
|
max_address = max(max_address, dest+length)
|
|
remapped_datas = bytearray(b"\x00"*max_address)
|
|
for [beg, length, dest] in offsets_map:
|
|
remapped_datas[dest:dest+length] = datas[beg:beg+length]
|
|
for beg,end,byte in intervals:
|
|
remapped_datas[beg:end] = byte * (end - beg)
|
|
for [beg, length, dest] in offsets_map:
|
|
datas[beg:beg+length] = remapped_datas[dest:dest+length]
|
|
return datas
|
|
|
|
|
|
def create_dol(dol_name:str, descriptors_list:list, bss_addr:int = 20, bss_length:int = 100, entry_point:int = 0):
|
|
"""
|
|
input: [DolDescriptor, ...]
|
|
create a dol with specified values in dol_tests_path
|
|
"""
|
|
descriptors_list.sort(key=lambda x:x.index)
|
|
|
|
offsets = b""
|
|
address = b""
|
|
lengths = b""
|
|
tmp_list = copy.deepcopy(descriptors_list)
|
|
for index in range(18):
|
|
if tmp_list:
|
|
if tmp_list[0].index == index:
|
|
offsets += tmp_list[0].boffset()
|
|
address += tmp_list[0].baddress()
|
|
lengths += tmp_list[0].blength()
|
|
|
|
tmp_list.pop(0)
|
|
continue
|
|
offsets += b"\x00\x00\x00\x00"
|
|
address += b"\x00\x00\x00\x00"
|
|
lengths += b"\x00\x00\x00\x00"
|
|
|
|
datas = (offsets + address + lengths + (bss_addr + 0x80003100).to_bytes(4,"big") + bss_length.to_bytes(4,"big") + (entry_point + 0x80003100).to_bytes(4,"big")).ljust(0x100, b"\x00")
|
|
|
|
descriptors_list.sort(key=lambda x:x.offset)
|
|
for descriptor in descriptors_list:
|
|
if len(datas) != descriptor.offset: raise Exception("doltest.py - Invalid dol creation offset.")
|
|
datas += descriptor.byte * descriptor.length
|
|
Path(dol_tests_path / dol_name).write_bytes(datas)
|
|
|
|
|
|
def to_action_replay_list(memory_objects:list):
|
|
arc_list = []
|
|
for memory_object in memory_objects:
|
|
arc_list.append(ActionReplayCode("04003100 12345678", 0))
|
|
arc_list[-1].set_address(memory_object.address())
|
|
arc_list[-1].set_end_address(memory_object.end_address())
|
|
arc_list[-1].set_datas(b"a" * memory_object.length())
|
|
return arc_list
|
|
|
|
|
|
def memory_objects_to_ini_txt(memory_objects:list):
|
|
str_buffer = ""
|
|
for memory_object in memory_objects:
|
|
addr = memory_object.address() & 0x01FFFFFF
|
|
str_buffer += f""
|
|
if memory_object.length() == 4:
|
|
str_buffer += f"{addr | 0x04000000:08x} " + f"{memory_object.datas()[0]:02x}"*4 + "\n"
|
|
elif memory_object.length() % 2 == 0:
|
|
str_buffer += f"{addr | 0x02000000:08x} {((memory_object.length() // 2) - 1):04x}" + f"{memory_object.datas()[0]:02x}"*2 + "\n"
|
|
else:
|
|
str_buffer += f"{addr:08x} {(memory_object.length() - 1):06x}" + f"{memory_object.datas()[0]:02x}" + "\n"
|
|
return str_buffer
|
|
|
|
|
|
def create_memory_objects_from_intervals(*intervals:list):
|
|
'Create memory objects list from intervals.'
|
|
if intervals is None:
|
|
return None
|
|
res = []
|
|
for interval in intervals:
|
|
memory_object = MemoryObject(0x80003100 + interval[0], end_address = 0x80003100 + interval[1])
|
|
res.append( memory_object )
|
|
if len(interval) == 3:
|
|
memory_object.set_datas(interval[2] * memory_object.length())
|
|
return res
|
|
|
|
|
|
TEST_COUNT = 8
|
|
start = time()
|
|
print("###############################################################################")
|
|
print("# Checking tests folder")
|
|
print("###############################################################################")
|
|
# Check if tests folders exist
|
|
if ini_path.is_dir() or dol_tests_path.is_dir() or dols_save_path.is_dir():
|
|
raise Exception(f"Error - Please remove:\n-{ini_path}\n-{dol_tests_path}\n-{dols_save_path}")
|
|
|
|
print("###############################################################################")
|
|
print(f"# TEST 1/{TEST_COUNT}")
|
|
print("# Testing valid dol.resolve_img2virtual conversion.")
|
|
print("###############################################################################")
|
|
dol = Dol(Path("eu.dol"))
|
|
print("Testing first offset of each segments with correct output:")
|
|
for (offset, virtual_address) in [(0x100, 0x80003100), (0x25e0, 0x800055e0), (0x2aede0, 0x802b1de0), (0x2aee00, 0x802b1e00), (0x2aee20, 0x802b1e20), (0x2bde80, 0x802c0e80), (0x3b3bc0, 0x8043cbe0), (0x3b66e0, 0x80440080)]:
|
|
if dol.resolve_img2virtual(offset) == virtual_address:
|
|
print("Correct translation")
|
|
else:
|
|
raise Exception(f"Error - resolve_img2virtual invalid translation for offset {offset:08x}: {virtual_address:08x}.")
|
|
|
|
print("Testing last offset of each segments with correct output:")
|
|
for (offset, virtual_address) in [(0x100 + 0x24e0 - 1, 0x800055e0 - 1), (0x25e0 + 0x2ac800 - 1, 0x802b1de0 - 1), (0x2aede0 + 0x20 - 1, 0x802b1e00 - 1), (0x2aee00 + 0x20 - 1, 0x802b1e20 - 1), (0x2aee20 + 0xf060 - 1, 0x802c0e80 - 1), (0x2bde80 + 0xf5d40 - 1, 0x803b6bc0 - 1), (0x3b3bc0 + 0x2b20 - 1, 0x8043f700 - 1), (0x3b66e0 + 0x6d20 - 1, 0x80446da0 - 1)]:
|
|
if dol.resolve_img2virtual(offset) == virtual_address:
|
|
print("Correct translation")
|
|
else:
|
|
raise Exception(f"Error - resolve_img2virtual invalid translation for offset {offset:08x}: {virtual_address:08x}.")
|
|
|
|
print("Testing first and last offset out of file datas to raise Exception:")
|
|
for invalid_offset in [0x9f, 0x3bd400]:
|
|
try:
|
|
dol.resolve_img2virtual(invalid_offset)
|
|
raise Exception("Error - InvalidImgOffsetError Exception should have been triggered.")
|
|
except InvalidImgOffsetError:
|
|
print("Correct InvalidImgOffsetError triggered.")
|
|
|
|
print("###############################################################################")
|
|
print(f"# TEST 2/{TEST_COUNT}")
|
|
print("# Testing valid dol.resolve_virtual2img conversion.")
|
|
print("###############################################################################")
|
|
print("Testing first virtual address of each segments with correct output:")
|
|
for (offset, virtual_address) in [(0x100, 0x80003100), (0x25e0, 0x800055e0), (0x2aede0, 0x802b1de0), (0x2aee00, 0x802b1e00), (0x2aee20, 0x802b1e20), (0x2bde80, 0x802c0e80), (0x3b3bc0, 0x8043cbe0), (0x3b66e0, 0x80440080)]:
|
|
if dol.resolve_virtual2img(virtual_address) == offset:
|
|
print("Correct translation")
|
|
else:
|
|
print(f"{dol.resolve_virtual2img(virtual_address):08x}")
|
|
raise Exception(f"Error - resolve_virtual2img invalid translation for offset {virtual_address:08x}:{offset:08x}.")
|
|
|
|
print("Testing last virtual address of each segments with correct output:")
|
|
for (offset, virtual_address) in [(0x100 + 0x24e0 - 1, 0x800055e0 - 1), (0x25e0 + 0x2ac800 - 1, 0x802b1de0 - 1), (0x2aede0 + 0x20 - 1, 0x802b1e00 - 1), (0x2aee00 + 0x20 - 1, 0x802b1e20 - 1), (0x2aee20 + 0xf060 - 1, 0x802c0e80 - 1), (0x2bde80 + 0xf5d40 - 1, 0x803b6bc0 - 1), (0x3b3bc0 + 0x2b20 - 1, 0x8043f700 - 1), (0x3b66e0 + 0x6d20 - 1, 0x80446da0 - 1)]:
|
|
if dol.resolve_virtual2img(virtual_address) == offset:
|
|
print("Correct translation")
|
|
else:
|
|
raise Exception(f"Error - resolve_virtual2img invalid translation for offset {virtual_address:08x}:{offset:08x}.")
|
|
|
|
print("Testing bounding virtual addresses of non existing offset to raise Exception:")
|
|
for invalid_offset in [0x800030ff, 0x803b6bc0, 0x803b6bc0, 0x8043cbe0 - 1, 0x8043f700, 0x80440080 - 1, 0x80446da0, 0x80446dc8, 0x81800000]:
|
|
try:
|
|
dol.resolve_virtual2img(invalid_offset)
|
|
raise Exception("Error - InvalidVirtualAddressError Exception should have been triggered.")
|
|
except InvalidVirtualAddressError:
|
|
print("Correct InvalidVirtualAddressError triggered.")
|
|
|
|
print("###############################################################################")
|
|
print(f"# TEST 3/{TEST_COUNT}")
|
|
print("# Testing MemoryObject.")
|
|
print("###############################################################################")
|
|
print("Testing __init__ & __str__")
|
|
# address:int, section_type:SectionType = SectionType.UNMAPPED, name:str = None, length:int = None, end_address:int = None
|
|
memory_object1 = MemoryObject(0x80003100 + 100, SectionType.BSS, "abcd", length=10)
|
|
if str(memory_object1) != f"| {'abcd'.ljust(11)} | {0x80003100+100:08x} | {0x80003100+110:08x} | {10:08x} |" or memory_object1.type() != SectionType.BSS:
|
|
raise Exception("Invalid MemoryObject constructor or __str__.")
|
|
|
|
memory_object2 = MemoryObject(0x80003100 + 200, name="efgh", end_address=0x80003100 + 310)
|
|
if str(memory_object2) != f"| {'efgh'.ljust(11)} | {0x80003100+200:08x} | {0x80003100+310:08x} | {110:08x} |" or memory_object2.type() != SectionType.UNMAPPED:
|
|
raise Exception("Invalid MemoryObject constructor or __str__.")
|
|
|
|
print("Testing set_address and set_name")
|
|
memory_object1.set_end_address(0x80003100 + 200)
|
|
memory_object1.set_name("blah")
|
|
if str(memory_object1) != f"| {'blah'.ljust(11)} | {0x80003100+100:08x} | {0x80003100+200:08x} | {100:08x} |":
|
|
raise Exception("Invalid MemoryObject set_end_address.")
|
|
|
|
print("Testing set_end_address")
|
|
memory_object1.set_address(0x80003100 + 150)
|
|
if str(memory_object1) != f"| {'blah'.ljust(11)} | {0x80003100+150:08x} | {0x80003100+200:08x} | {50:08x} |":
|
|
raise Exception("Invalid MemoryObject set_address.")
|
|
|
|
print("Testing OutOfMemoryError")
|
|
MemoryObject(0x811fffff, length = 1)
|
|
MemoryObject(0x80003100, length = 1)
|
|
try:
|
|
MemoryObject(0x800030ff, length = 2)
|
|
raise Exception("Error - OutOfMemoryError should have been triggered.")
|
|
except OutOfMemoryError:
|
|
print("Correct OutOfMemoryError triggered.")
|
|
try:
|
|
MemoryObject(0x80003000, end_address = 0x80003800)
|
|
raise Exception("Error - OutOfMemoryError should have been triggered.")
|
|
except OutOfMemoryError:
|
|
print("Correct OutOfMemoryError triggered.")
|
|
try:
|
|
MemoryObject(0x811fff00, end_address = 0x811fff00 + 0x200)
|
|
raise Exception("Error - OutOfMemoryError should have been triggered.")
|
|
except OutOfMemoryError:
|
|
print("Correct OutOfMemoryError triggered.")
|
|
try:
|
|
MemoryObject(0x811fffff, length = 2)
|
|
raise Exception("Error - OutOfMemoryError should have been triggered.")
|
|
except OutOfMemoryError:
|
|
print("Correct OutOfMemoryError triggered.")
|
|
try:
|
|
MemoryObject(0x81200000, length = 1)
|
|
raise Exception("Error - OutOfMemoryError should have been triggered.")
|
|
except OutOfMemoryError:
|
|
print("Correct OutOfMemoryError triggered.")
|
|
|
|
print("Testing __sub__:")
|
|
interval = MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20)
|
|
|
|
for [intervals_to_remove, expected_res] in [
|
|
[[[0,10]], [[10,20]]], # Before with match
|
|
[[[20,30]], [[10,20]]], # After with match
|
|
[[[0,10],[20,30]], [[10,20]]], # Before and after
|
|
[[[0,11],[20,30]], [[11,20]]], # left truncate
|
|
[[[0,11],[19,30]], [[11,19]]], # left and right truncate
|
|
[[[0,10],[19,30]], [[10,19]]], # right truncate
|
|
[[[0,11],[12,13],[14,15],[19,30]], [[11,12],[13,14],[15,19]]], # left middle and right truncate
|
|
[[[0,11],[11,13],[13,15],[19,30]], [[15,19]]], # following truncates left truncate rigth truncate
|
|
[[[0,11],[11,13],[13,15],[15,20]], None], # following truncates overlap with end match
|
|
[[[10,13],[13,15],[15,25]], None], # following truncates overlap with begin match
|
|
[[[10,13],[13,15],[15,20]], None], # following truncates in with begin and end match
|
|
[[[11,13],[13,15],[15,19]], [[10,11],[19,20]]], # following truncates in
|
|
[[[10,13],[13,15],[15,19]], [[19,20]]], # following truncates in with begin match
|
|
[[[11,13],[13,15],[15,20]], [[10,11]]], # following truncates in with end match
|
|
[[[0,30]], None], # total overlap overflowing left right
|
|
[[[10,30]], None], # total overlap overflowing left
|
|
[[[0,20]], None], # total overlap overflowing right
|
|
[[[10,20]], None]]: # total match
|
|
res_interval = interval - create_memory_objects_from_intervals( *intervals_to_remove )
|
|
|
|
expected_res = create_memory_objects_from_intervals(*expected_res) if expected_res is not None else None
|
|
if expected_res is None and res_interval is None:
|
|
print("Correct result.")
|
|
continue
|
|
|
|
if len(res_interval) != len(expected_res):
|
|
raise Exception("Error - Invalid __sub__ result.")
|
|
|
|
for index, res_interval in enumerate(res_interval):
|
|
if res_interval.address() != expected_res[index].address() or res_interval.end_address() != expected_res[index].end_address():
|
|
raise Exception("Error - Invalid __sub__ result.")
|
|
print("Correct result.")
|
|
|
|
interval = MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20)
|
|
|
|
print("Testing __lt__:")
|
|
for interval_lt, expected_res in [
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 9), True], # __lt__
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 10), True], # __lt__ matching
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 11), False], # __le__ + 1 byte
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 11), False], # __le__ + 1 byte - 1 byte
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 20), False], # __le__ - 1 byte with matching
|
|
[MemoryObject(0x80003100 + 11, end_address=0x80003100 + 19), False], # __contains__
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 15), False], # __contains__ matching left
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20), False], # __contains__ matching left and right
|
|
[MemoryObject(0x80003100 + 15, end_address=0x80003100 + 20), False], # __contains__ matching right
|
|
[MemoryObject(0x80003100 + 15, end_address=0x80003100 + 21), False], # __ge__ + 1 byte
|
|
[MemoryObject(0x80003100 + 19, end_address=0x80003100 + 21), False], # __ge__ + 1 byte - 1 byte
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 21), False], # __ge__ + 1 byte with matching
|
|
[MemoryObject(0x80003100 + 20, end_address=0x80003100 + 25), False], # __gt__ matching
|
|
[MemoryObject(0x80003100 + 21, end_address=0x80003100 + 25), False], # __gt__
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 21), False], # total overlap
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 21), False], # total overlap matching left
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 20), False]]: # total overlap matching right
|
|
if (interval_lt < interval) != expected_res:
|
|
raise Exception("Error - Invalid __lt__ result.")
|
|
else:
|
|
print("Correct result.")
|
|
|
|
print("Testing __le__:")
|
|
for interval_le, expected_res in [
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 9), False], # __lt__
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 10), False], # __lt__ matching
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 11), True], # __le__ + 1 byte
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 11), True], # __le__ + 1 byte - 1 byte
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 20), True], # __le__ - 1 byte with matching
|
|
[MemoryObject(0x80003100 + 11, end_address=0x80003100 + 19), False], # __contains__
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 15), False], # __contains__ matching left
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20), False], # __contains__ matching left and right
|
|
[MemoryObject(0x80003100 + 15, end_address=0x80003100 + 20), False], # __contains__ matching right
|
|
[MemoryObject(0x80003100 + 15, end_address=0x80003100 + 21), False], # __ge__ + 1 byte
|
|
[MemoryObject(0x80003100 + 19, end_address=0x80003100 + 21), False], # __ge__ + 1 byte - 1 byte
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 21), False], # __ge__ + 1 byte with matching
|
|
[MemoryObject(0x80003100 + 20, end_address=0x80003100 + 25), False], # __gt__ matching
|
|
[MemoryObject(0x80003100 + 21, end_address=0x80003100 + 25), False], # __gt__
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 21), False], # total overlap
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 21), False], # total overlap matching left
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 20), True]]: # total overlap matching right
|
|
if (interval_le <= interval) != expected_res:
|
|
raise Exception("Error - Invalid __le__ result.")
|
|
else:
|
|
print("Correct result.")
|
|
|
|
print("Testing __ge__:")
|
|
for interval_ge, expected_res in [
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 9), False], # __lt__
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 10), False], # __lt__ matching
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 11), False], # __le__ + 1 byte
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 11), False], # __le__ + 1 byte - 1 byte
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 20), False], # __le__ - 1 byte with matching
|
|
[MemoryObject(0x80003100 + 11, end_address=0x80003100 + 19), False], # __contains__
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 15), False], # __contains__ matching left
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20), False], # __contains__ matching left and right
|
|
[MemoryObject(0x80003100 + 15, end_address=0x80003100 + 20), False], # __contains__ matching right
|
|
[MemoryObject(0x80003100 + 15, end_address=0x80003100 + 21), True], # __ge__ + 1 byte
|
|
[MemoryObject(0x80003100 + 19, end_address=0x80003100 + 21), True], # __ge__ + 1 byte - 1 byte
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 21), True], # __ge__ + 1 byte with matching
|
|
[MemoryObject(0x80003100 + 20, end_address=0x80003100 + 25), False], # __gt__ matching
|
|
[MemoryObject(0x80003100 + 21, end_address=0x80003100 + 25), False], # __gt__
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 21), False], # total overlap
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 21), True], # total overlap matching left
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 20), False]]: # total overlap matching right
|
|
if (interval_ge >= interval) != expected_res:
|
|
raise Exception("Error - Invalid __ge__ result.")
|
|
else:
|
|
print("Correct result.")
|
|
|
|
print("Testing __gt__:")
|
|
for interval_gt, expected_res in [
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 9), False], # __lt__
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 10), False], # __lt__ matching
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 11), False], # __le__ + 1 byte
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 11), False], # __le__ + 1 byte - 1 byte
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 20), False], # __le__ - 1 byte with matching
|
|
[MemoryObject(0x80003100 + 11, end_address=0x80003100 + 19), False], # __contains__
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 15), False], # __contains__ matching left
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20), False], # __contains__ matching left and right
|
|
[MemoryObject(0x80003100 + 15, end_address=0x80003100 + 20), False], # __contains__ matching right
|
|
[MemoryObject(0x80003100 + 15, end_address=0x80003100 + 21), False], # __ge__ + 1 byte
|
|
[MemoryObject(0x80003100 + 19, end_address=0x80003100 + 21), False], # __ge__ + 1 byte - 1 byte
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 21), False], # __ge__ + 1 byte with matching
|
|
[MemoryObject(0x80003100 + 20, end_address=0x80003100 + 25), True], # __gt__ matching
|
|
[MemoryObject(0x80003100 + 21, end_address=0x80003100 + 25), True], # __gt__
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 21), False], # total overlap
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 21), False], # total overlap matching left
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 20), False]]: # total overlap matching right
|
|
if (interval_gt > interval) != expected_res:
|
|
raise Exception("Error - Invalid __gt__ result.")
|
|
else:
|
|
print("Correct result.")
|
|
|
|
print("Testing __contains__:")
|
|
for interval_contains, expected_res in [
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 9), False], # __lt__
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 10), False], # __lt__ matching
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 11), False], # __le__ + 1 byte
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 11), False], # __le__ + 1 byte - 1 byte
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 20), False], # __le__ - 1 byte with matching
|
|
[MemoryObject(0x80003100 + 11, end_address=0x80003100 + 19), True], # __contains__
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 15), True], # __contains__ matching left
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20), True], # __contains__ matching left and right
|
|
[MemoryObject(0x80003100 + 15, end_address=0x80003100 + 20), True], # __contains__ matching right
|
|
[MemoryObject(0x80003100 + 15, end_address=0x80003100 + 21), False], # __ge__ + 1 byte
|
|
[MemoryObject(0x80003100 + 19, end_address=0x80003100 + 21), False], # __ge__ + 1 byte - 1 byte
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 21), False], # __ge__ + 1 byte with matching
|
|
[MemoryObject(0x80003100 + 20, end_address=0x80003100 + 25), False], # __gt__ matching
|
|
[MemoryObject(0x80003100 + 21, end_address=0x80003100 + 25), False], # __gt__
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 21), False], # total overlap
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 21), False], # total overlap matching left
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 20), False]]: # total overlap matching right
|
|
if (interval_contains in interval) != expected_res:
|
|
raise Exception("Error - Invalid __contains__ result.")
|
|
else:
|
|
print("Correct result.")
|
|
|
|
print("Testing __and__:")
|
|
for interval_and, expected_res in [
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 9), False], # __lt__
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 10), False], # __lt__ matching
|
|
[MemoryObject(0x80003100 + 0, end_address=0x80003100 + 11), True], # __le__ + 1 byte
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 11), True], # __le__ + 1 byte - 1 byte
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 20), True], # __le__ - 1 byte with matching
|
|
[MemoryObject(0x80003100 + 11, end_address=0x80003100 + 19), True], # __contains__
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 15), True], # __contains__ matching left
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20), True], # __contains__ matching left and right
|
|
[MemoryObject(0x80003100 + 15, end_address=0x80003100 + 20), True], # __contains__ matching right
|
|
[MemoryObject(0x80003100 + 15, end_address=0x80003100 + 21), True], # __ge__ + 1 byte
|
|
[MemoryObject(0x80003100 + 19, end_address=0x80003100 + 21), True], # __ge__ + 1 byte - 1 byte
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 21), True], # __ge__ + 1 byte with matching
|
|
[MemoryObject(0x80003100 + 20, end_address=0x80003100 + 25), False], # __gt__ matching
|
|
[MemoryObject(0x80003100 + 21, end_address=0x80003100 + 25), False], # __gt__
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 21), True], # total overlap
|
|
[MemoryObject(0x80003100 + 10, end_address=0x80003100 + 21), True], # total overlap matching left
|
|
[MemoryObject(0x80003100 + 9, end_address=0x80003100 + 20), True]]: # total overlap matching right
|
|
if (interval_and & interval) != expected_res:
|
|
raise Exception("Error - Invalid __and__ result.")
|
|
else:
|
|
print("Correct result.")
|
|
|
|
print("Testing __truediv__:")
|
|
intervals_truediv = []
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 0, end_address=0x80003100 + 9) )
|
|
intervals_truediv[0].set_datas(b"l"*9)
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 0, end_address=0x80003100 + 10) )
|
|
intervals_truediv[1].set_datas(b"l"*10)
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 0, end_address=0x80003100 + 11) )
|
|
intervals_truediv[2].set_datas(b"l"*10 + b"i")
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 9, end_address=0x80003100 + 11) )
|
|
intervals_truediv[3].set_datas(b"l" + b"i")
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 9, end_address=0x80003100 + 20) )
|
|
intervals_truediv[4].set_datas(b"l" + 10*b"i")
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 11, end_address=0x80003100 + 19) )
|
|
intervals_truediv[5].set_datas(b"i"*8)
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 10, end_address=0x80003100 + 15) )
|
|
intervals_truediv[6].set_datas(b"i"*5)
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20) )
|
|
intervals_truediv[7].set_datas(b"i"*10)
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 15, end_address=0x80003100 + 20) )
|
|
intervals_truediv[8].set_datas(b"i"*5)
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 15, end_address=0x80003100 + 21) )
|
|
intervals_truediv[9].set_datas(b"i"*5 + b"r")
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 19, end_address=0x80003100 + 21) )
|
|
intervals_truediv[10].set_datas(b"i" + b"r")
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 10, end_address=0x80003100 + 21) )
|
|
intervals_truediv[11].set_datas(b"i"*10 + b"r")
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 20, end_address=0x80003100 + 25) )
|
|
intervals_truediv[12].set_datas(b"r"*5)
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 21, end_address=0x80003100 + 25) )
|
|
intervals_truediv[13].set_datas(b"r"*4)
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 9, end_address=0x80003100 + 21) )
|
|
intervals_truediv[14].set_datas(b"l" + b"i"*10 + b"r")
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 10, end_address=0x80003100 + 21) )
|
|
intervals_truediv[15].set_datas(b"i"*10 + b"r")
|
|
intervals_truediv.append( MemoryObject(0x80003100 + 9, end_address=0x80003100 + 20) )
|
|
intervals_truediv[16].set_datas(b"l" + b"i"*10)
|
|
|
|
expected_truediv_res = []
|
|
expected_truediv_res.append(None) # __lt__
|
|
expected_truediv_res.append(None) # __lt__ matching
|
|
|
|
# __le__ + 1 byte
|
|
expected_truediv_res.append({IntervalDiv.LEFT: MemoryObject(0x80003100 + 0, end_address=0x80003100 + 10), IntervalDiv.IN: MemoryObject(0x80003100 + 10, end_address=0x80003100 + 11)})
|
|
expected_truediv_res[2][IntervalDiv.LEFT].set_datas(b"l"*10)
|
|
expected_truediv_res[2][IntervalDiv.IN].set_datas(b"i")
|
|
|
|
# __le__ + 1 byte - 1 byte
|
|
expected_truediv_res.append({IntervalDiv.LEFT: MemoryObject(0x80003100 + 9, end_address=0x80003100 + 10), IntervalDiv.IN: MemoryObject(0x80003100 + 10, end_address=0x80003100 + 11)})
|
|
expected_truediv_res[3][IntervalDiv.LEFT].set_datas(b"l")
|
|
expected_truediv_res[3][IntervalDiv.IN].set_datas(b"i")
|
|
|
|
# __le__ - 1 byte with matching
|
|
expected_truediv_res.append({IntervalDiv.LEFT: MemoryObject(0x80003100 + 9, end_address=0x80003100 + 10), IntervalDiv.IN: MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20)})
|
|
expected_truediv_res[4][IntervalDiv.LEFT].set_datas(b"l")
|
|
expected_truediv_res[4][IntervalDiv.IN].set_datas(b"i"*10)
|
|
|
|
# __contains__
|
|
expected_truediv_res.append({IntervalDiv.IN: MemoryObject(0x80003100 + 11, end_address=0x80003100 + 19)})
|
|
expected_truediv_res[5][IntervalDiv.IN].set_datas(b"i"*8)
|
|
|
|
# __contains__ matching left
|
|
expected_truediv_res.append({IntervalDiv.IN: MemoryObject(0x80003100 + 10, end_address=0x80003100 + 15)})
|
|
expected_truediv_res[6][IntervalDiv.IN].set_datas(b"i"*5)
|
|
|
|
# __contains__ matching left and right
|
|
expected_truediv_res.append({IntervalDiv.IN: MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20)})
|
|
expected_truediv_res[7][IntervalDiv.IN].set_datas(b"i"*10)
|
|
|
|
# __contains__ matching right
|
|
expected_truediv_res.append({IntervalDiv.IN: MemoryObject(0x80003100 + 15, end_address=0x80003100 + 20)})
|
|
expected_truediv_res[8][IntervalDiv.IN].set_datas(b"i"*5)
|
|
|
|
# __ge__ + 1 byte
|
|
expected_truediv_res.append({IntervalDiv.IN: MemoryObject(0x80003100 + 15, end_address=0x80003100 + 20), IntervalDiv.RIGHT: MemoryObject(0x80003100 + 20, end_address=0x80003100 + 21)})
|
|
expected_truediv_res[9][IntervalDiv.IN].set_datas(b"i"*5)
|
|
expected_truediv_res[9][IntervalDiv.RIGHT].set_datas(b"r")
|
|
|
|
# __ge__ + 1 byte - 1 byte
|
|
expected_truediv_res.append({IntervalDiv.IN: MemoryObject(0x80003100 + 19, end_address=0x80003100 + 20), IntervalDiv.RIGHT: MemoryObject(0x80003100 + 20, end_address=0x80003100 + 21)})
|
|
expected_truediv_res[10][IntervalDiv.IN].set_datas(b"i")
|
|
expected_truediv_res[10][IntervalDiv.RIGHT].set_datas(b"r")
|
|
|
|
# __ge__ + 1 byte with matching
|
|
expected_truediv_res.append({IntervalDiv.IN: MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20), IntervalDiv.RIGHT: MemoryObject(0x80003100 + 20, end_address=0x80003100 + 21)})
|
|
expected_truediv_res[11][IntervalDiv.IN].set_datas(b"i"*10)
|
|
expected_truediv_res[11][IntervalDiv.RIGHT].set_datas(b"r")
|
|
|
|
expected_truediv_res.append(None) # __gt__ matching
|
|
expected_truediv_res.append(None) # __gt__
|
|
|
|
# total overlap
|
|
expected_truediv_res.append({IntervalDiv.LEFT: MemoryObject(0x80003100 + 9, end_address=0x80003100 + 10), IntervalDiv.IN: MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20), IntervalDiv.RIGHT: MemoryObject(0x80003100 + 20, end_address=0x80003100 + 21)})
|
|
expected_truediv_res[14][IntervalDiv.LEFT].set_datas(b"l")
|
|
expected_truediv_res[14][IntervalDiv.IN].set_datas(b"i"*10)
|
|
expected_truediv_res[14][IntervalDiv.RIGHT].set_datas(b"r")
|
|
|
|
# total overlap matching left
|
|
expected_truediv_res.append({IntervalDiv.IN: MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20), IntervalDiv.RIGHT: MemoryObject(0x80003100 + 20, end_address=0x80003100 + 21)})
|
|
expected_truediv_res[15][IntervalDiv.IN].set_datas(b"i"*10)
|
|
expected_truediv_res[15][IntervalDiv.RIGHT].set_datas(b"r")
|
|
|
|
# total overlap matching right
|
|
expected_truediv_res.append({IntervalDiv.LEFT: MemoryObject(0x80003100 + 9, end_address=0x80003100 + 10), IntervalDiv.IN: MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20)})
|
|
expected_truediv_res[16][IntervalDiv.LEFT].set_datas(b"l")
|
|
expected_truediv_res[16][IntervalDiv.IN].set_datas(b"i"*10)
|
|
|
|
for index in range(len(expected_truediv_res)):
|
|
interval_truediv = intervals_truediv[index]
|
|
expected_res = expected_truediv_res[index]
|
|
|
|
new_intervals = interval_truediv / interval
|
|
if expected_res is None and new_intervals is None:
|
|
print("Correct result")
|
|
continue
|
|
|
|
for key in expected_res.keys():
|
|
if key not in new_intervals:
|
|
raise Exception("Error - Invalid __truediv__ result.")
|
|
if new_intervals[key].address() != expected_res[key].address() or new_intervals[key].end_address() != expected_res[key].end_address() or new_intervals[key].datas() != expected_res[key].datas():
|
|
raise Exception("Error - Invalid __truediv__ result.")
|
|
print("Correct result.")
|
|
|
|
print("Testing to_memory_object:")
|
|
memory_object3 = MemoryObject(0x80003100 + 20, end_address=0x80003100 + 42)
|
|
|
|
print("Testing set_datas:")
|
|
memory_object3.set_datas(b"11333333333333333333BB")
|
|
if memory_object3.datas() != b"11333333333333333333BB":
|
|
raise Exception("Error - Invalid set_datas result.")
|
|
print("Correct result.")
|
|
|
|
memory_object3.set_datas(b"00112233445566778899AA")
|
|
if memory_object3.datas() != b"00112233445566778899AA":
|
|
raise Exception("Error - Invalid set_datas result.")
|
|
print("Correct result.")
|
|
|
|
print("Testing update_datas:")
|
|
update = MemoryObject(0x80003100 + 21, end_address=0x80003100 + 41)
|
|
update.set_datas(b"cccccccccccccccccccc")
|
|
memory_object3.update_datas(update)
|
|
if memory_object3.datas() != b"0ccccccccccccccccccccA":
|
|
raise Exception("Error - Invalid update_datas result.")
|
|
print("Correct result.")
|
|
|
|
update.set_datas(b"9999999999999999999999")
|
|
update.set_address(0x80003100 + 20)
|
|
update.set_end_address(0x80003100 + 42)
|
|
memory_object3.update_datas(update)
|
|
if memory_object3.datas() != b"9999999999999999999999":
|
|
raise Exception("Error - Invalid update_datas result.")
|
|
print("Correct result.")
|
|
|
|
print("Testing align:")
|
|
memory_object3.set_address(0x80003100 + 3)
|
|
memory_object3.set_end_address(0x80003100 + 9)
|
|
memory_object3.align()
|
|
if memory_object3.address() != 0x80003100 + 0 or memory_object3.end_address() != 0x80003100 + 32:
|
|
raise Exception("Error - Invalid align result.")
|
|
print("Correct result.")
|
|
|
|
print("###############################################################################")
|
|
print(f"# TEST 4/{TEST_COUNT}")
|
|
print("# Testing valid action_replay_code parsing.")
|
|
print("###############################################################################")
|
|
ini_path.mkdir()
|
|
dol_tests_path.mkdir()
|
|
valid_action_replay_ini = "[ActionReplay_Enabled]\n$Costs\n$HP\n$B Ammo and Refill Codes\n$B Mode and Reload Codes\n"+\
|
|
"$X Ammo and Refill Codes\n$X Mode and Reload Codes\n$Warehouse Full\n\n[ActionReplay]\n$Costs\n022E2CC0 00050096\n"+\
|
|
"022E2CCC 00050136\n022E2CD8 0005012C\n022E2CE4 000500D2\n042E4E2A 0000005A\n042E4F92 000001E0\n042E50FA 0000005A\n"+\
|
|
"042E5262 0001003C\n042E53CA 00000078\n042E5532 0000003C\n042E569A 0000003C\n042E5802 00000078\n042E596A 0000000A\n"+\
|
|
"003CE5C2 00000003\n0040E5C2 00000344\n"
|
|
|
|
(ini_path / "test1.ini").write_text(valid_action_replay_ini)
|
|
action_replay_list = parse_action_replay_ini(ini_path / "test1.ini")
|
|
|
|
expected_res6 = [
|
|
(int("802E2CC0", 16), b"\x00\x96\x00\x96\x00\x96\x00\x96\x00\x96\x00\x96"),
|
|
(int("802E2CCC", 16), b"\x01\x36\x01\x36\x01\x36\x01\x36\x01\x36\x01\x36"),
|
|
(int("802E2CD8", 16), b"\x01\x2C\x01\x2C\x01\x2C\x01\x2C\x01\x2C\x01\x2C"),
|
|
(int("802E2CE4", 16), b"\x00\xD2\x00\xD2\x00\xD2\x00\xD2\x00\xD2\x00\xD2"),
|
|
(int("802E4E2A", 16), b"\x00\x00\x00\x5A"),
|
|
(int("802E4F92", 16), b"\x00\x00\x01\xE0"),
|
|
(int("802E50FA", 16), b"\x00\x00\x00\x5A"),
|
|
(int("802E5262", 16), b"\x00\x01\x00\x3C"),
|
|
(int("802E53CA", 16), b"\x00\x00\x00\x78"),
|
|
(int("802E5532", 16), b"\x00\x00\x00\x3C"),
|
|
(int("802E569A", 16), b"\x00\x00\x00\x3C"),
|
|
(int("802E5802", 16), b"\x00\x00\x00\x78"),
|
|
(int("802E596A", 16), b"\x00\x00\x00\x0A"),
|
|
(int("803CE5C2", 16), b"\x03"),
|
|
(int("8040E5C2", 16), b"\x44\x44\x44\x44")]
|
|
if len(expected_res6) != len(action_replay_list):
|
|
raise Exception("Error - Invalid ini parsing.")
|
|
for index, exp_res in enumerate(expected_res6):
|
|
if action_replay_list[index].address() != expected_res6[index][0] or action_replay_list[index].datas() != expected_res6[index][1]:
|
|
raise Exception("Error - Invalid ini parsing.")
|
|
print("Valid parsing as Expected.")
|
|
|
|
for invalid_action_replay_ini in ["a\n082E2CC0 00050096\n","0A02E2CC0 00050096","082E2CC0 00050096", "\n122E2CC0 00050096\n"]:
|
|
try:
|
|
(ini_path / "test2.ini").write_text(invalid_action_replay_ini)
|
|
parse_action_replay_ini(ini_path / "test2.ini")
|
|
raise Exception("Error - InvalidIniFileEntryError Exception should have been triggered.")
|
|
except InvalidIniFileEntryError:
|
|
print("Correct InvalidIniFileEntryError triggered.")
|
|
# 41200000
|
|
for invalid_action_replay_ini in ["\n020030ff 00050096\n","05200000 00050096","05800000 00050096", "\n02000000 04050096\n"]:
|
|
try:
|
|
(ini_path / "test3.ini").write_text(invalid_action_replay_ini)
|
|
parse_action_replay_ini(ini_path / "test3.ini")
|
|
raise Exception("Error - OutOfMemoryError Exception should have been triggered.")
|
|
except OutOfMemoryError:
|
|
print("Correct OutOfMemoryError triggered.")
|
|
|
|
print("###############################################################################")
|
|
print(f"# TEST 5/{TEST_COUNT}")
|
|
print("# Testing intervals functions.")
|
|
print("###############################################################################")
|
|
print("Testing _Dol__get_merged_mapped_memory.")
|
|
# There is always sections
|
|
# * Sections never overlap
|
|
# * unsorted intervals
|
|
|
|
create_dol("dol0.dol", [
|
|
DolDescriptor(index=0, offset=107, address=160, length=40, byte=b"a"), # [160, 200] # * > 1 spacing
|
|
DolDescriptor(index=1, offset=95, address=128, length=12, byte=b"b"), # [128, 140] # * 0 spacing x2
|
|
DolDescriptor(index=3, offset=63, address=96, length=32, byte=b"b"), # [96, 128] # * 0 spacing
|
|
DolDescriptor(index=5, offset=0, address=32, length=31, byte=b"c"), # [32, 63]
|
|
DolDescriptor(index=7, offset=31, address=64, length=32, byte=b"d")]) # [64, 96] # * 1 spacing between two intervals
|
|
expected_res7 = create_memory_objects_from_intervals([32,63],[64,140],[160,200])
|
|
|
|
dol0 = Dol(dol_tests_path / "dol0.dol")
|
|
merged_list = dol0._Dol__get_merged_mapped_memory()
|
|
|
|
if len(expected_res7) != len(merged_list):
|
|
raise Exception("Error - Invalid merged_list.")
|
|
|
|
for index, merged in enumerate(merged_list):
|
|
if merged.address() != expected_res7[index].address() or merged.end_address() != expected_res7[index].end_address():
|
|
raise Exception("Error - Invalid intervals merge.")
|
|
print("Correct result.")
|
|
|
|
print("Testing get_overlapping_arcodes.")
|
|
arcode0 = ActionReplayCode("04003100 AAAAAAAA", 1)
|
|
arcode1 = ActionReplayCode("04003104 BBBBBBBB", 2) # matching
|
|
arcode2 = ActionReplayCode("04003107 BBBBBBBB", 3) # overlapping from 1 byte
|
|
arcode3 = ActionReplayCode("0400310C BBBBBBBB", 4) # interval 1 byte
|
|
arcode4 = ActionReplayCode("0400310C BBBBBBBB", 5) # total overlap
|
|
arcode5 = ActionReplayCode("0400310E BBBBBBBB", 6) # overlapping from 2 bytes
|
|
arcode6 = ActionReplayCode("02003114 000FBBBB", 7) # overlapping totaly next
|
|
arcode7 = ActionReplayCode("04003118 ABCFBBBB", 8) # totaly overlapped
|
|
|
|
expected_res8 = [[arcode1, arcode2], [arcode3, arcode4], [arcode4, arcode5], [arcode6, arcode7]]
|
|
|
|
overlaps0 = get_overlapping_arcodes([arcode0,arcode1,arcode2,arcode3,arcode4,arcode5,arcode6,arcode7])
|
|
if len(overlaps0) != len(expected_res8):
|
|
raise Exception("Error - Invalid get_overlapping_arcodes result.")
|
|
|
|
for index, (overlap0, overlap1) in enumerate(overlaps0):
|
|
if overlap0 != expected_res8[index][0] or overlap1 != expected_res8[index][1]:
|
|
raise Exception("Error - Invalid get_overlapping_arcodes result.")
|
|
|
|
print("Testing get_unmapped_intervals.")
|
|
merged_memo_res = [[ # Testing all limits
|
|
create_memory_objects_from_intervals([50,75],[100,200],[250,260],[270,280],[300,400]),
|
|
create_memory_objects_from_intervals(
|
|
[0,5], # before all intervals group
|
|
[10,12],[15,20], [25,50], # map before
|
|
# in group
|
|
[50,75], # in with begin and end map
|
|
# new group
|
|
[80,90], # between group
|
|
[91,92], # between group
|
|
[94,95], # between group
|
|
[95,101], # overlap begining with 1 byte
|
|
# in group
|
|
[101,195], # in match previous interval to test end and next interval to test begin
|
|
[195,200], # in with end map
|
|
# empty group
|
|
[250,258], # in with begin map
|
|
# new group
|
|
[259,264], # overlap ending with 1 byte
|
|
# new group
|
|
[280,285], # map after
|
|
# new group
|
|
[420,430], # after group
|
|
[450,470]),
|
|
create_memory_objects_from_intervals([0,50],[80,100],[260,264],[280,285],[420,470]),
|
|
],[ # All before with overlap
|
|
create_memory_objects_from_intervals([75,200],[250,260],[270,280]),
|
|
create_memory_objects_from_intervals([0,5],[10,12],[15,20],[25,50],[50,76]),
|
|
create_memory_objects_from_intervals([0,75])
|
|
],[ # All after with overlap
|
|
create_memory_objects_from_intervals([50,75],[100,120],[140,196]),
|
|
create_memory_objects_from_intervals([195,200],[250,258],[259,264],[450,470]),
|
|
create_memory_objects_from_intervals([196,470])
|
|
],[ # All between with overlap
|
|
create_memory_objects_from_intervals([10,20],[50,196],[469,520],[600,700]),
|
|
create_memory_objects_from_intervals(
|
|
[195,200], # before overlap
|
|
[250,258], # between
|
|
[259,264], # between
|
|
[450,470]), # after overlap
|
|
create_memory_objects_from_intervals([196, 469])
|
|
],[ # All between with begin and end match
|
|
create_memory_objects_from_intervals([10,20],[50,196],[469,520],[600,700]),
|
|
create_memory_objects_from_intervals([196,200], [250,258], [259,264], [450,469]),
|
|
create_memory_objects_from_intervals([196, 469])
|
|
],[ # All in
|
|
create_memory_objects_from_intervals([0,500]),
|
|
create_memory_objects_from_intervals([195,200],[250,258],[259,264],[450,470]),
|
|
None
|
|
]]
|
|
for merged_intervals, memory_objects_list, expected_res in merged_memo_res:
|
|
unmapped_intervals = get_unmapped_intervals(merged_intervals, to_action_replay_list(memory_objects_list))
|
|
if expected_res is None and unmapped_intervals is None:
|
|
print("Corrects get_unmapped_intervals test.")
|
|
continue
|
|
|
|
if len(unmapped_intervals) != len(expected_res):
|
|
raise Exception(f"Error - get_unmapped_intervals invalid result.")
|
|
|
|
for index, unmapped_interval in enumerate(unmapped_intervals):
|
|
if expected_res[index].address() != unmapped_interval.address() or expected_res[index].end_address() != unmapped_interval.end_address():
|
|
raise Exception(f"Error - get_unmapped_intervals invalid result.")
|
|
print("Corrects get_unmapped_intervals test.")
|
|
|
|
print("###############################################################################")
|
|
print(f"# TEST 6/{TEST_COUNT}")
|
|
print("# Testing Section align.")
|
|
print("###############################################################################")
|
|
# index:int, offset:int, address:int, length:int)
|
|
|
|
try:
|
|
Section(0, 0x1000, 0x80003101, 10)
|
|
except InvalidSectionAlignError:
|
|
print("Correct invalid Section align.")
|
|
try:
|
|
Section(0, 0x1000, 0x8000311F, 10)
|
|
except InvalidSectionAlignError:
|
|
print("Correct invalid Section align.")
|
|
|
|
print("###############################################################################")
|
|
print(f"# TEST 7/{TEST_COUNT}")
|
|
print("# Testing dol._Dol__save.")
|
|
print("###############################################################################")
|
|
dols_save_path.mkdir()
|
|
for input_path in dols_path.glob("*"):
|
|
dol = Dol(input_path)
|
|
dol._Dol__save(dols_save_path / input_path.name)
|
|
if input_path.read_bytes() != (dols_save_path / input_path.name).read_bytes():
|
|
raise Exception(f"Error - Invalid dol parsing and save for dol {input_path}.")
|
|
else:
|
|
print(f"Correct parsing and saving.")
|
|
|
|
print("###############################################################################")
|
|
print(f"# TEST 8/{TEST_COUNT}")
|
|
print("# Testing --patch-action-replay commands.")
|
|
print("###############################################################################")
|
|
# Testing correct patch between two section + 1
|
|
# Sections: [0, 32], [32, 64], [64, 96], [96, 128], [128, 160], [160, 192], [192, 224], [224, 256], [256, 288],
|
|
# [288, 320], [320, 352], [352, 384], [384, 416], [416, 448]
|
|
print("Following sections sorted with offset == address; offset != address and so on.")
|
|
# Following sections sorted by offset
|
|
create_dol("dol1.dol", [
|
|
DolDescriptor(index=0, offset=0, address=0, length=32, byte=b"\x10"),
|
|
DolDescriptor(index=2, offset=32, address=32, length=32, byte=b"\x20"),
|
|
DolDescriptor(index=3, offset=64, address=64, length=32, byte=b"\x30"),
|
|
DolDescriptor(index=5, offset=96, address=96, length=32, byte=b"\x40"),
|
|
DolDescriptor(index=8, offset=128, address=128, length=32, byte=b"\x50"),
|
|
DolDescriptor(index=9, offset=160, address=160, length=32, byte=b"\x60"),
|
|
DolDescriptor(index=10, offset=192, address=192, length=32, byte=b"\x70"),
|
|
DolDescriptor(index=11, offset=224, address=224, length=32, byte=b"\x80"),
|
|
DolDescriptor(index=12, offset=256, address=256, length=32, byte=b"\x90"),
|
|
DolDescriptor(index=13, offset=288, address=288, length=32, byte=b"\xA0"),
|
|
DolDescriptor(index=14, offset=320, address=320, length=32, byte=b"\xB0"),
|
|
DolDescriptor(index=15, offset=352, address=352, length=32, byte=b"\xC0"),
|
|
DolDescriptor(index=16, offset=384, address=384, length=32, byte=b"\xD0"),
|
|
DolDescriptor(index=17, offset=416, address=416, length=32, byte=b"\xE0")])
|
|
# Following sections reverse sorted by offset
|
|
# Here there can't be out overlappings because of address sorting.
|
|
create_dol("dol2.dol", [
|
|
DolDescriptor(index=0, offset=416, address=416, length=32, byte=b"\xE0"),
|
|
DolDescriptor(index=2, offset=384, address=384, length=32, byte=b"\xD0"),
|
|
DolDescriptor(index=3, offset=352, address=352, length=32, byte=b"\xC0"),
|
|
DolDescriptor(index=5, offset=320, address=320, length=32, byte=b"\xB0"),
|
|
DolDescriptor(index=8, offset=288, address=288, length=32, byte=b"\xA0"),
|
|
DolDescriptor(index=9, offset=256, address=256, length=32, byte=b"\x90"),
|
|
DolDescriptor(index=10, offset=224, address=224, length=32, byte=b"\x80"),
|
|
DolDescriptor(index=11, offset=192, address=192, length=32, byte=b"\x70"),
|
|
DolDescriptor(index=12, offset=160, address=160, length=32, byte=b"\x60"),
|
|
DolDescriptor(index=13, offset=128, address=128, length=32, byte=b"\x50"),
|
|
DolDescriptor(index=14, offset=96, address=96, length=32, byte=b"\x40"),
|
|
DolDescriptor(index=15, offset=64, address=64, length=32, byte=b"\x30"),
|
|
DolDescriptor(index=16, offset=32, address=32, length=32, byte=b"\x20"),
|
|
DolDescriptor(index=17, offset=0, address=0, length=32, byte=b"\x10")])
|
|
# Following sections shuffled
|
|
# Here there can't be out overlappings because of address sorting.
|
|
# Following sections unsorted by offset
|
|
create_dol("dol3.dol", [
|
|
DolDescriptor(index=0, offset=192, address=192, length=32, byte=b"\x70"),
|
|
DolDescriptor(index=2, offset=64, address=64, length=32, byte=b"\x30"),
|
|
DolDescriptor(index=3, offset=160, address=160, length=32, byte=b"\x60"),
|
|
DolDescriptor(index=5, offset=288, address=288, length=32, byte=b"\xA0"),
|
|
DolDescriptor(index=8, offset=128, address=128, length=32, byte=b"\x50"),
|
|
DolDescriptor(index=9, offset=32, address=32, length=32, byte=b"\x20"),
|
|
DolDescriptor(index=10, offset=96, address=96, length=32, byte=b"\x40"),
|
|
DolDescriptor(index=11, offset=224, address=224, length=32, byte=b"\x80"),
|
|
DolDescriptor(index=12, offset=416, address=416, length=32, byte=b"\xE0"),
|
|
DolDescriptor(index=13, offset=352, address=352, length=32, byte=b"\xC0"),
|
|
DolDescriptor(index=14, offset=320, address=320, length=32, byte=b"\xB0"),
|
|
DolDescriptor(index=15, offset=384, address=384, length=32, byte=b"\xD0"),
|
|
DolDescriptor(index=16, offset=0, address=0, length=32, byte=b"\x10"),
|
|
DolDescriptor(index=17, offset=256, address=256, length=32, byte=b"\x90")])
|
|
|
|
|
|
mappeurs_dict = {}
|
|
|
|
# Sames as previously but with offset reverse sorted / shuffled / from addresses
|
|
create_dol("dol4.dol", [
|
|
DolDescriptor(index=0, offset=416, address=0, length=32, byte=b"\x10"),
|
|
DolDescriptor(index=2, offset=384, address=32, length=32, byte=b"\x20"),
|
|
DolDescriptor(index=3, offset=352, address=64, length=32, byte=b"\x30"),
|
|
DolDescriptor(index=5, offset=320, address=96, length=32, byte=b"\x40"),
|
|
DolDescriptor(index=8, offset=288, address=128, length=32, byte=b"\x50"),
|
|
DolDescriptor(index=9, offset=256, address=160, length=32, byte=b"\x60"),
|
|
DolDescriptor(index=10, offset=224, address=192, length=32, byte=b"\x70"),
|
|
DolDescriptor(index=11, offset=192, address=224, length=32, byte=b"\x80"),
|
|
DolDescriptor(index=12, offset=160, address=256, length=32, byte=b"\x90"),
|
|
DolDescriptor(index=13, offset=128, address=288, length=32, byte=b"\xA0"),
|
|
DolDescriptor(index=14, offset=96, address=320, length=32, byte=b"\xB0"),
|
|
DolDescriptor(index=15, offset=64, address=352, length=32, byte=b"\xC0"),
|
|
DolDescriptor(index=16, offset=32, address=384, length=32, byte=b"\xD0"),
|
|
DolDescriptor(index=17, offset=0, address=416, length=32, byte=b"\xE0")])
|
|
mappeurs_dict[4] = [
|
|
[416, 32, 0],
|
|
[384, 32, 32],
|
|
[352, 32, 64],
|
|
[320, 32, 96],
|
|
[288, 32, 128],
|
|
[256, 32, 160],
|
|
[224, 32, 192],
|
|
[192, 32, 224],
|
|
[160, 32, 256],
|
|
[128, 32, 288],
|
|
[96, 32, 320],
|
|
[64, 32, 352],
|
|
[32, 32, 384],
|
|
[0, 32, 416]]
|
|
|
|
create_dol("dol5.dol", [
|
|
DolDescriptor(index=0, offset=0, address=416, length=32, byte=b"\xE0"),
|
|
DolDescriptor(index=2, offset=32, address=384, length=32, byte=b"\xD0"),
|
|
DolDescriptor(index=3, offset=64, address=352, length=32, byte=b"\xC0"),
|
|
DolDescriptor(index=5, offset=96, address=320, length=32, byte=b"\xB0"),
|
|
DolDescriptor(index=8, offset=128, address=288, length=32, byte=b"\xA0"),
|
|
DolDescriptor(index=9, offset=160, address=256, length=32, byte=b"\x90"),
|
|
DolDescriptor(index=10, offset=192, address=224, length=32, byte=b"\x80"),
|
|
DolDescriptor(index=11, offset=224, address=192, length=32, byte=b"\x70"),
|
|
DolDescriptor(index=12, offset=256, address=160, length=32, byte=b"\x60"),
|
|
DolDescriptor(index=13, offset=288, address=128, length=32, byte=b"\x50"),
|
|
DolDescriptor(index=14, offset=320, address=96, length=32, byte=b"\x40"),
|
|
DolDescriptor(index=15, offset=352, address=64, length=32, byte=b"\x30"),
|
|
DolDescriptor(index=16, offset=384, address=32, length=32, byte=b"\x20"),
|
|
DolDescriptor(index=17, offset=416, address=0, length=32, byte=b"\x10")])
|
|
mappeurs_dict[5] = [
|
|
[0, 32, 416],
|
|
[32, 32, 384],
|
|
[64, 32, 352],
|
|
[96, 32, 320],
|
|
[128, 32, 288],
|
|
[160, 32, 256],
|
|
[192, 32, 224],
|
|
[224, 32, 192],
|
|
[256, 32, 160],
|
|
[288, 32, 128],
|
|
[320, 32, 96],
|
|
[352, 32, 64],
|
|
[384, 32, 32],
|
|
[416, 32, 0]]
|
|
|
|
create_dol("dol6.dol", [
|
|
DolDescriptor(index=0, offset=416, address=192, length=32, byte=b"\x70"),
|
|
DolDescriptor(index=2, offset=0, address=64, length=32, byte=b"\x30"),
|
|
DolDescriptor(index=3, offset=192, address=160, length=32, byte=b"\x60"),
|
|
DolDescriptor(index=5, offset=160, address=288, length=32, byte=b"\xA0"),
|
|
DolDescriptor(index=8, offset=128, address=128, length=32, byte=b"\x50"),
|
|
DolDescriptor(index=9, offset=64, address=32, length=32, byte=b"\x20"),
|
|
DolDescriptor(index=10, offset=320, address=96, length=32, byte=b"\x40"),
|
|
DolDescriptor(index=11, offset=384, address=224, length=32, byte=b"\x80"),
|
|
DolDescriptor(index=12, offset=224, address=416, length=32, byte=b"\xE0"),
|
|
DolDescriptor(index=13, offset=32, address=352, length=32, byte=b"\xC0"),
|
|
DolDescriptor(index=14, offset=96, address=320, length=32, byte=b"\xB0"),
|
|
DolDescriptor(index=15, offset=288, address=384, length=32, byte=b"\xD0"),
|
|
DolDescriptor(index=16, offset=352, address=0, length=32, byte=b"\x10"),
|
|
DolDescriptor(index=17, offset=256, address=256, length=32, byte=b"\x90")])
|
|
mappeurs_dict[6] = [
|
|
[416, 32, 192],
|
|
[0, 32, 64],
|
|
[192, 32, 160],
|
|
[160, 32, 288],
|
|
[128, 32, 128],
|
|
[64, 32, 32],
|
|
[320, 32, 96],
|
|
[384, 32, 224],
|
|
[224, 32, 416],
|
|
[32, 32, 352],
|
|
[96, 32, 320],
|
|
[288, 32, 384],
|
|
[352, 32, 0],
|
|
[256, 32, 256]]
|
|
|
|
# Here there can't be out overlappings.
|
|
# Beginning of dol file # [0, 24] 24 \x11
|
|
# Middle -1 + 1 # [33, 63] 30 \x22
|
|
# Middle # [80, 84] 4 \x33
|
|
# Overlapping + 1 # [93, 97] 4 \x44
|
|
# Overlapping - 1 # [127, 131] 4 \x55
|
|
# Endin map # [156, 160] 4 \x66
|
|
# Begin map # [160, 164] 4 \x77
|
|
# Begin and ending map # [192, 224] 32 \x88
|
|
# Total overlapping +1 -1 # [255, 289] 34 \x99
|
|
# Total overlapping 3 sec # [319, 417] 98 \xAA
|
|
# Ending of dol file # [444, 448] 4 \xBB
|
|
# [[begin, end, byte], ...]
|
|
intervals_list = []
|
|
intervals_list.append([[0, 24, b"\x11"], [33, 63, b"\x22"], [80, 84, b"\x33"], [93, 97, b"\x44"],
|
|
[127, 131, b"\x55"], [156, 160, b"\x66"], [160, 164, b"\x77"], [192, 224, b"\x88"],
|
|
[255, 289, b"\x99"], [319, 417, b"\xAA"], [444, 448, b"\xBB"]])
|
|
# same reverse sorted
|
|
intervals_list.append(sorted(intervals_list[0], key=lambda x: x, reverse=True))
|
|
# same but shuffled
|
|
intervals_list.append([[156, 160, b"\x66"], [255, 289, b"\x99"], [160, 164, b"\x77"], [93, 97, b"\x44"],\
|
|
[444, 448, b"\xBB"], [80, 84, b"\x33"], [319, 417, b"\xAA"], [33, 63, b"\x22"],\
|
|
[0, 24, b"\x11"], [127, 131, b"\x55"], [192, 224, b"\x88"]])
|
|
|
|
# just to remember, sames sections:
|
|
# [0, 32], [32, 64], [64, 96], [96, 128], [128, 160], [160, 192], [192, 224], [224, 256], [256, 288],
|
|
# [288, 320], [320, 352], [352, 384], [384, 416], [416, 448]
|
|
intervals_list.append([
|
|
[24, 64, b"\x11"], # overlap left match right
|
|
[96, 130, b"\x22"], # overlap right match left
|
|
[120, 170, b"\x33"], # overlap left and right
|
|
[191, 225, b"\x44"], # overlap left and right +1-1
|
|
[255, 353, b"\x55"]]) # overlap left and right +- 3 sections (reversed)
|
|
intervals_list.append([ # same but reverse sorted
|
|
[255, 353, b"\x11"], # overlap left and right +- 3 sections (reversed)
|
|
[191, 225, b"\x22"], # overlap left and right +1-1
|
|
[120, 170, b"\x33"], # overlap left and right
|
|
[96, 130, b"\x44"], # overlap right match left
|
|
[24, 64, b"\x55"]]) # overlap left match right
|
|
intervals_list.append([ # same but shuffled
|
|
[120, 170, b"\x11"], # overlap left and right
|
|
[255, 353, b"\x22"], # overlap left and right +- 3 sections (reversed)
|
|
[96, 130, b"\x33"], # overlap right match left
|
|
[24, 64, b"\x44"], # overlap left match right
|
|
[191, 225, b"\x55"]]) # overlap left and right +1-1
|
|
# total file patch
|
|
# overlap right (match left) 3 sections dol1 <- sorted
|
|
# overlap left match right 3 sections dol3 <- reverse sorted
|
|
intervals_list.append([[0, 448, b"\x11"]])
|
|
# overlap left and right +3 sections
|
|
# overlap left and right -3 sections
|
|
intervals_list.append([[254, 448, b"\x11"]])
|
|
# overlap left and right +-3 sections <- dol2 1st section
|
|
intervals_list.append([[100, 340, b"\x11"]])
|
|
# one byte patch test
|
|
intervals_list.append([[100, 101, b"\x11"], [105, 110, b"\x22"]])
|
|
|
|
"""
|
|
dol123_datas = b"".join(list(map(lambda x: x.to_bytes(4, "big"), [
|
|
0x100+0, 0, 0x100+32, 0x100+64, 0, 0x100+96, 0, 0, 0x100+128, 0x100+160, 0x100+192, 0x100+224, 0x100+256, 0x100+288, 0x100+320, 0x100+352, 0x100+384, 0x100+416,
|
|
0x80003100+0, 0, 0x80003100+32, 0x80003100+64, 0, 0x80003100+96, 0, 0, 0x80003100+128, 0x80003100+160, 0x80003100+192, 0x80003100+224, 0x80003100+256, 0x80003100+288, 0x80003100+320, 0x80003100+352, 0x80003100+384, 0x80003100+416,
|
|
32, 0, 32, 32, 0, 32, 0, 0, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
|
|
0x80003100+20,100, 0x80003100]))).ljust(0x100, b"\x00") + b"\x10"*32 + b"\x20"*32 + \
|
|
b"\x30"*32 + b"\x40"*32 + b"\x50"*32 + b"\x60"*32 + b"\x70"*32 + b"\x80"*32 + b"\x90"*32 + b"\xA0"*32 + b"\xB0"*32 + \
|
|
b"\xC0"*32 + b"\xD0"*32 + b"\xE0"*32
|
|
"""
|
|
def test_dols(range_dols, intervals_list:list):
|
|
for interval_index, intervals in enumerate(intervals_list):
|
|
for dol_index in range_dols:
|
|
dol_path = f"dol{dol_index}.dol"
|
|
dol_patched_path = f"dol{dol_index}_{interval_index}_patched.dol"
|
|
dol_ini_path = f"dol{dol_index}_{interval_index}.ini"
|
|
|
|
# write ini file with same sorting than intervals
|
|
(ini_path / dol_ini_path).write_text( memory_objects_to_ini_txt(create_memory_objects_from_intervals(*intervals)) )
|
|
|
|
dol_datas = bytearray((dol_tests_path / dol_path).read_bytes())
|
|
dol_header = dol_datas[:0x100]
|
|
dol_datas = dol_datas[0x100:]
|
|
|
|
if dol_index in mappeurs_dict:
|
|
dol_datas = map_offsets(dol_datas, mappeurs_dict[dol_index], intervals)
|
|
else:
|
|
for beg,end,byte in intervals:
|
|
dol_datas[beg:end] = byte * (end - beg)
|
|
|
|
Path(dol_tests_path / f"dol{dol_index}_{interval_index}_patched.dol.expected").write_bytes(dol_header + dol_datas)
|
|
|
|
doltool_par(dol_tests_path / dol_path, dol_tests_path / dol_patched_path, ini_path / dol_ini_path)
|
|
if dol_header + dol_datas != (dol_tests_path / dol_patched_path).read_bytes():
|
|
print(interval_index, intervals)
|
|
raise Exception("Error - Invalid -par result.")
|
|
test_dols(range(1,7), intervals_list)
|
|
# Testing Overflowing at the end of section + 1
|
|
intervals_list = []
|
|
intervals_list.append([[445, 449, b"\x11"], [33, 63, b"\x22"]])
|
|
intervals_list.append([[0, 24, b"\x11"], [445, 449, b"\x22"]])
|
|
intervals_list.append([[0, 24, b"\x11"], [447, 451, b"\x22"]])
|
|
intervals_list.append([[447, 451, b"\x11"], [33, 63, b"\x22"]])
|
|
intervals_list.append([[447, 451, b"\x11"]])
|
|
intervals_list.append([[445, 449, b"\x11"]])
|
|
intervals_list.append([[446, 449, b"\x11"]])
|
|
intervals_list.append([[447, 450, b"\x11"]])
|
|
intervals_list.append([[447, 456, b"\x11"]])
|
|
|
|
for interval_index, intervals in enumerate(intervals_list):
|
|
for dol_index in range(1,7):
|
|
try:
|
|
dol_ini_path = f"dol{dol_index}_{interval_index}_exception.ini"
|
|
(ini_path / dol_ini_path).write_text( memory_objects_to_ini_txt(create_memory_objects_from_intervals(*intervals)) )
|
|
|
|
dol = Dol(dol_tests_path / f"dol{dol_index}.dol")
|
|
|
|
action_replay_list = parse_action_replay_ini(ini_path / dol_ini_path)
|
|
dol.patch_memory_objects(dol_tests_path / f"dol{dol_index}_patched.dol", action_replay_list)
|
|
|
|
raise Exception("Error - SectionsOverflowError Exception should have been triggered.")
|
|
except SectionsOverflowError:
|
|
print("Correct SectionsOverflowError triggered.")
|
|
|
|
mappeurs_dict = {}
|
|
# Sections: [0, 32], [96, 128], [128, 160], [224, 256], [256, 288], [288, 320], [352, 384], [384, 416], [416, 448]
|
|
print("Following sections sorted with offset == address - section patch using offset is safe.")
|
|
# Following sections sorted by offset
|
|
create_dol("dol7.dol", [
|
|
DolDescriptor(index=1, offset=0, address=0, length=32, byte=b"\x10"),
|
|
DolDescriptor(index=5, offset=32, address=96, length=32, byte=b"\x40"),
|
|
DolDescriptor(index=8, offset=64, address=128, length=32, byte=b"\x50"),
|
|
DolDescriptor(index=10, offset=96, address=224, length=32, byte=b"\x80"),
|
|
DolDescriptor(index=11, offset=128, address=256, length=32, byte=b"\x90"),
|
|
DolDescriptor(index=12, offset=160, address=288, length=32, byte=b"\xA0"),
|
|
DolDescriptor(index=13, offset=192, address=352, length=32, byte=b"\xC0"),
|
|
DolDescriptor(index=14, offset=224, address=384, length=32, byte=b"\xD0"),
|
|
DolDescriptor(index=15, offset=256, address=416, length=32, byte=b"\xE0")])
|
|
mappeurs_dict[7] = [
|
|
[0, 32, 0],
|
|
[32, 32, 96],
|
|
[64, 32, 128],
|
|
[96, 32, 224],
|
|
[128, 32, 256],
|
|
[160, 32, 288],
|
|
[192, 32, 352],
|
|
[224, 32, 384],
|
|
[256, 32, 416]]
|
|
|
|
# Following sections reverse sorted by offset
|
|
create_dol("dol8.dol", [
|
|
DolDescriptor(index=1, offset=256, address=416, length=32, byte=b"\xE0"),
|
|
DolDescriptor(index=5, offset=224, address=384, length=32, byte=b"\xD0"),
|
|
DolDescriptor(index=8, offset=192, address=352, length=32, byte=b"\xC0"),
|
|
DolDescriptor(index=10, offset=160, address=288, length=32, byte=b"\xA0"),
|
|
DolDescriptor(index=11, offset=128, address=256, length=32, byte=b"\x90"),
|
|
DolDescriptor(index=12, offset=96, address=224, length=32, byte=b"\x80"),
|
|
DolDescriptor(index=13, offset=64, address=128, length=32, byte=b"\x50"),
|
|
DolDescriptor(index=14, offset=32, address=96, length=32, byte=b"\x40"),
|
|
DolDescriptor(index=15, offset=0, address=0, length=32, byte=b"\x10")])
|
|
mappeurs_dict[8] = [
|
|
[256, 32, 416],
|
|
[224, 32, 384],
|
|
[192, 32, 352],
|
|
[160, 32, 288],
|
|
[128, 32, 256],
|
|
[96, 32, 224],
|
|
[64, 32, 128],
|
|
[32, 32, 96],
|
|
[0, 32, 0]]
|
|
|
|
# shuffled
|
|
# Following sections unsorted by offset
|
|
create_dol("dol9.dol", [
|
|
DolDescriptor(index=1, offset=64, address=128, length=32, byte=b"\x50"),
|
|
DolDescriptor(index=5, offset=0, address=0, length=32, byte=b"\x10"),
|
|
DolDescriptor(index=8, offset=32, address=96, length=32, byte=b"\x40"),
|
|
DolDescriptor(index=10, offset=224, address=384, length=32, byte=b"\xD0"),
|
|
DolDescriptor(index=11, offset=192, address=352, length=32, byte=b"\xC0"),
|
|
DolDescriptor(index=12, offset=96, address=224, length=32, byte=b"\x80"),
|
|
DolDescriptor(index=13, offset=256, address=416, length=32, byte=b"\xE0"),
|
|
DolDescriptor(index=14, offset=160, address=288, length=32, byte=b"\xA0"),
|
|
DolDescriptor(index=15, offset=128, address=256, length=32, byte=b"\x90")])
|
|
mappeurs_dict[9] = [
|
|
[64, 32, 128],
|
|
[0, 32, 0],
|
|
[32, 32, 96],
|
|
[224, 32, 384],
|
|
[192, 32, 352],
|
|
[96, 32, 224],
|
|
[256, 32, 416],
|
|
[160, 32, 288],
|
|
[128, 32, 256]]
|
|
|
|
# Sames as previously but with offset reverse sorted / shuffled / from addresses
|
|
# offset reverse sorted from address
|
|
create_dol("dol10.dol", [
|
|
DolDescriptor(index=1, offset=256, address=0, length=32, byte=b"\x10"),
|
|
DolDescriptor(index=5, offset=224, address=96, length=32, byte=b"\x40"),
|
|
DolDescriptor(index=8, offset=192, address=128, length=32, byte=b"\x50"),
|
|
DolDescriptor(index=10, offset=160, address=224, length=32, byte=b"\x80"),
|
|
DolDescriptor(index=11, offset=128, address=256, length=32, byte=b"\x90"),
|
|
DolDescriptor(index=12, offset=96, address=288, length=32, byte=b"\xA0"),
|
|
DolDescriptor(index=13, offset=64, address=352, length=32, byte=b"\xC0"),
|
|
DolDescriptor(index=14, offset=32, address=384, length=32, byte=b"\xD0"),
|
|
DolDescriptor(index=15, offset=0, address=416, length=32, byte=b"\xE0")])
|
|
mappeurs_dict[10] = [
|
|
[256, 32, 0],
|
|
[224, 32, 96],
|
|
[192, 32, 128],
|
|
[160, 32, 224],
|
|
[128, 32, 256],
|
|
[96, 32, 288],
|
|
[64, 32, 352],
|
|
[32, 32, 384],
|
|
[0, 32, 416]]
|
|
|
|
# offset reverse sorted from address / reversed
|
|
create_dol("dol11.dol", [
|
|
DolDescriptor(index=1, offset=0, address=416, length=32, byte=b"\xE0"),
|
|
DolDescriptor(index=5, offset=32, address=384, length=32, byte=b"\xD0"),
|
|
DolDescriptor(index=8, offset=64, address=352, length=32, byte=b"\xC0"),
|
|
DolDescriptor(index=10, offset=96, address=288, length=32, byte=b"\xA0"),
|
|
DolDescriptor(index=11, offset=128, address=256, length=32, byte=b"\x90"),
|
|
DolDescriptor(index=12, offset=160, address=224, length=32, byte=b"\x80"),
|
|
DolDescriptor(index=13, offset=192, address=128, length=32, byte=b"\x50"),
|
|
DolDescriptor(index=14, offset=224, address=96, length=32, byte=b"\x40"),
|
|
DolDescriptor(index=15, offset=256, address=0, length=32, byte=b"\x10")])
|
|
mappeurs_dict[11] = [
|
|
[0, 32, 416],
|
|
[32, 32, 384],
|
|
[64, 32, 352],
|
|
[96, 32, 288],
|
|
[128, 32, 256],
|
|
[160, 32, 224],
|
|
[192, 32, 128],
|
|
[224, 32, 96],
|
|
[256, 32, 0]]
|
|
|
|
# offset shuffled from address
|
|
create_dol("dol12.dol", [
|
|
DolDescriptor(index=1, offset=192, address=128, length=32, byte=b"\x50"),
|
|
DolDescriptor(index=5, offset=224, address=0, length=32, byte=b"\x10"),
|
|
DolDescriptor(index=8, offset=160, address=96, length=32, byte=b"\x40"),
|
|
DolDescriptor(index=10, offset=64, address=384, length=32, byte=b"\xD0"),
|
|
DolDescriptor(index=11, offset=0, address=352, length=32, byte=b"\xC0"),
|
|
DolDescriptor(index=12, offset=32, address=224, length=32, byte=b"\x80"),
|
|
DolDescriptor(index=13, offset=128, address=416, length=32, byte=b"\xE0"),
|
|
DolDescriptor(index=14, offset=256, address=288, length=32, byte=b"\xA0"),
|
|
DolDescriptor(index=15, offset=96, address=256, length=32, byte=b"\x90")])
|
|
mappeurs_dict[12] = [
|
|
[192, 32, 128],
|
|
[224, 32, 0],
|
|
[160, 32, 96],
|
|
[64, 32, 384],
|
|
[0, 32, 352],
|
|
[32, 32, 224],
|
|
[128, 32, 416],
|
|
[256, 32, 288],
|
|
[96, 32, 256]]
|
|
# Overlapping +3 sections matching right # [126, 320]
|
|
# Middle -1 + 1 # [353, 383] \x55
|
|
intervals_list = []
|
|
# Sections: [0, 32], [96, 128], [128, 160], [224, 256], [256, 288], [288, 320], [352, 384], [384, 416], [416, 448]
|
|
# Beginning of dol file # [0, 24] \x11
|
|
# Matching right before empty # [28, 32] \x22
|
|
# Matching left after empty # [96, 100] \x33
|
|
# Overlapping +3 sections matching right # [225, 383] \x55
|
|
# Middle # [390, 394] \x66
|
|
# Endin map with overlap # [414, 448] \x77
|
|
# [[begin, end, byte], ...]
|
|
intervals_list.append([[0, 24, b"\x11"], [28, 32, b"\x22"], [96, 100, b"\x33"],
|
|
[224, 320, b"\x44"], [225, 319, b"\x55"], [390, 394, b"\x66"], [414, 448, b"\x77"]])
|
|
intervals_list.append(sorted(intervals_list[0], key=lambda x: x, reverse=True))
|
|
intervals_list.append([[414, 448, b"\x77"], [353, 383, b"\x55"], [96, 100, b"\x33"], [390, 394, b"\x66"], [28, 32, b"\x22"], [224, 320, b"\x44"], [0, 24, b"\x11"]])
|
|
|
|
# Total file patch
|
|
intervals_list.append([[0, 32, b"\x11"], [96, 160, b"\x22"], [224, 320, b"\x33"], [352, 448, b"\x44"]])
|
|
intervals_list.append(sorted(intervals_list[1], key=lambda x: x, reverse=True))
|
|
intervals_list.append([[96, 160, b"\x22"], [0, 32, b"\x11"], [352, 448, b"\x44"], [224, 320, b"\x33"]])
|
|
# same but shuffled
|
|
|
|
test_dols(range(7,12), intervals_list)
|
|
|
|
print("###############################################################################")
|
|
print(f"# Cleaning test folders.")
|
|
print("###############################################################################")
|
|
shutil.rmtree(ini_path)
|
|
shutil.rmtree(dol_tests_path)
|
|
shutil.rmtree(dols_save_path)
|
|
|
|
end = time()
|
|
print("###############################################################################")
|
|
print(f"# All tests are OK - elapsed time: {end - start}")
|
|
print("###############################################################################")
|