Virtual-World-RE/NeoGF
4
0
Fork 0
mirror of https://github.com/Virtual-World-RE/NeoGF.git synced 2024-11-15 07:45:33 +01:00
Code Issues Releases Wiki Activity

Added test for 00 arcode 1 byte write

Browse Source
This commit is contained in:
tmpz23 2022-06-12 07:09:48 +02:00 committed by GitHub
parent 420ec9ffe6
commit caab893c67
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 55 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
doltool/doltest.py
View File

@ -10,7 +10,7 @@ import shutil
from time import time from time import time
__version__ = "0.0.3" __version__ = "0.0.4"
__author__ = "rigodron, algoflash, GGLinnk" __author__ = "rigodron, algoflash, GGLinnk"
__license__ = "MIT" __license__ = "MIT"
__status__ = "developpement" __status__ = "developpement"
@ -58,6 +58,7 @@ class DolDescriptor:
def map_offsets(datas:bytes, offsets_map:list, intervals:list): 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 max_address = 0
for beg,length,dest in offsets_map: for beg,length,dest in offsets_map:
max_address = max(max_address, dest+length) max_address = max(max_address, dest+length)
@ -83,7 +84,7 @@ def create_dol(dol_name:str, descriptors_list:list, bss_addr:int = 20, bss_lengt
lengths = b"" lengths = b""
tmp_list = copy.deepcopy(descriptors_list) tmp_list = copy.deepcopy(descriptors_list)
for index in range(18): for index in range(18):
if len(tmp_list) > 0: if tmp_list:
if tmp_list[0].index == index: if tmp_list[0].index == index:
offsets += tmp_list[0].boffset() offsets += tmp_list[0].boffset()
address += tmp_list[0].baddress() address += tmp_list[0].baddress()
@ -124,12 +125,14 @@ def memory_objects_to_ini_txt(memory_objects:list):
elif memory_object.length() % 2 == 0: 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" str_buffer += f"{addr | 0x02000000:08x} {((memory_object.length() // 2) - 1):04x}" + f"{memory_object.datas()[0]:02x}"*2 + "\n"
else: else:
print(f"{memory_object.address():08x} {memory_object.length():08x}") str_buffer += f"{addr:08x} {(memory_object.length() - 1):06x}" + f"{memory_object.datas()[0]:02x}" + "\n"
raise("doltest: Invalid ARCode length - should be aligned to 2 or 4")
return str_buffer return str_buffer
def create_memory_objects_from_intervals(*intervals:list): def create_memory_objects_from_intervals(*intervals:list):
'Create memory objects list from intervals.'
if intervals is None:
return None
res = [] res = []
for interval in intervals: for interval in intervals:
memory_object = MemoryObject(0x80003100 + interval[0], end_address = 0x80003100 + interval[1]) memory_object = MemoryObject(0x80003100 + interval[0], end_address = 0x80003100 + interval[1])
@ -260,32 +263,31 @@ print("Testing __sub__:")
interval = MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20) interval = MemoryObject(0x80003100 + 10, end_address=0x80003100 + 20)
for [intervals_to_remove, expected_res] in [ for [intervals_to_remove, expected_res] in [
[create_memory_objects_from_intervals([0,10]), create_memory_objects_from_intervals([10,20])], # Before [[[0,10]], [[10,20]]], # Before with match
[create_memory_objects_from_intervals([20,30]), create_memory_objects_from_intervals([10,20])], # After [[[20,30]], [[10,20]]], # After with match
[create_memory_objects_from_intervals([0,10],[20,30]), create_memory_objects_from_intervals([10,20])], # Before and after [[[0,10],[20,30]], [[10,20]]], # Before and after
[create_memory_objects_from_intervals([0,11],[20,30]), create_memory_objects_from_intervals([11,20])], # left truncate [[[0,11],[20,30]], [[11,20]]], # left truncate
[create_memory_objects_from_intervals([0,11],[19,30]), create_memory_objects_from_intervals([11,19])], # left and right truncate [[[0,11],[19,30]], [[11,19]]], # left and right truncate
[create_memory_objects_from_intervals([0,10],[19,30]), create_memory_objects_from_intervals([10,19])], # right truncate [[[0,10],[19,30]], [[10,19]]], # right truncate
[create_memory_objects_from_intervals([0,11],[12,13],[14,15],[19,30]), create_memory_objects_from_intervals([11,12],[13,14],[15,19])], # left middle and right truncate [[[0,11],[12,13],[14,15],[19,30]], [[11,12],[13,14],[15,19]]], # left middle and right truncate
[create_memory_objects_from_intervals([0,11],[11,13],[13,15],[19,30]), create_memory_objects_from_intervals([15,19])], # following truncates left truncate rigth truncate [[[0,11],[11,13],[13,15],[19,30]], [[15,19]]], # following truncates left truncate rigth truncate
[create_memory_objects_from_intervals([0,11],[11,13],[13,15],[15,20]), None], # following truncates overlap with end match [[[0,11],[11,13],[13,15],[15,20]], None], # following truncates overlap with end match
[create_memory_objects_from_intervals([10,13],[13,15],[15,25]), None], # following truncates overlap with begin match [[[10,13],[13,15],[15,25]], None], # following truncates overlap with begin match
[create_memory_objects_from_intervals([10,13],[13,15],[15,20]), None], # following truncates in with begin and end match [[[10,13],[13,15],[15,20]], None], # following truncates in with begin and end match
[create_memory_objects_from_intervals([11,13],[13,15],[15,19]), create_memory_objects_from_intervals([10,11],[19,20])], # following truncates in [[[11,13],[13,15],[15,19]], [[10,11],[19,20]]], # following truncates in
[create_memory_objects_from_intervals([10,13],[13,15],[15,19]), create_memory_objects_from_intervals([19,20])], # following truncates in with begin match [[[10,13],[13,15],[15,19]], [[19,20]]], # following truncates in with begin match
[create_memory_objects_from_intervals([11,13],[13,15],[15,20]), create_memory_objects_from_intervals([10,11])], # following truncates in with end match [[[11,13],[13,15],[15,20]], [[10,11]]], # following truncates in with end match
[create_memory_objects_from_intervals([0,30]), None], # total overlap overflowing left right [[[0,30]], None], # total overlap overflowing left right
[create_memory_objects_from_intervals([10,30]), None], # total overlap overflowing left [[[10,30]], None], # total overlap overflowing left
[create_memory_objects_from_intervals([0,20]), None], # total overlap overflowing right [[[0,20]], None], # total overlap overflowing right
[create_memory_objects_from_intervals([10,20]), None]]: # total match [[[10,20]], None]]: # total match
res_interval = interval - intervals_to_remove 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: if expected_res is None and res_interval is None:
print("Correct result.") print("Correct result.")
continue continue
for a in res_interval:
print(a)
if len(res_interval) != len(expected_res): if len(res_interval) != len(expected_res):
raise Exception("Error - Invalid __sub__ result.") raise Exception("Error - Invalid __sub__ result.")
@ -606,7 +608,11 @@ print("# Testing valid action_replay_code parsing.")
print("###############################################################################") print("###############################################################################")
ini_path.mkdir() ini_path.mkdir()
dol_tests_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\n022E2CCC 00050136\n022E2CD8 0005012C\n022E2CE4 000500D2\n042E4E2A 0000005A\n042E4F92 000001E0\n042E50FA 0000005A\n042E5262 0001003C\n042E53CA 00000078\n042E5532 0000003C\n042E569A 0000003C\n042E5802 00000078\n042E596A 0000000A\n" 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) (ini_path / "test1.ini").write_text(valid_action_replay_ini)
action_replay_list = parse_action_replay_ini(ini_path / "test1.ini") action_replay_list = parse_action_replay_ini(ini_path / "test1.ini")
@ -624,7 +630,9 @@ expected_res6 = [
(int("802E5532", 16), b"\x00\x00\x00\x3C"), (int("802E5532", 16), b"\x00\x00\x00\x3C"),
(int("802E569A", 16), b"\x00\x00\x00\x3C"), (int("802E569A", 16), b"\x00\x00\x00\x3C"),
(int("802E5802", 16), b"\x00\x00\x00\x78"), (int("802E5802", 16), b"\x00\x00\x00\x78"),
(int("802E596A", 16), b"\x00\x00\x00\x0A")] (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): if len(expected_res6) != len(action_replay_list):
raise Exception("Error - Invalid ini parsing.") raise Exception("Error - Invalid ini parsing.")
for index, exp_res in enumerate(expected_res6): for index, exp_res in enumerate(expected_res6):
@ -632,7 +640,7 @@ for index, exp_res in enumerate(expected_res6):
raise Exception("Error - Invalid ini parsing.") raise Exception("Error - Invalid ini parsing.")
print("Valid parsing as Expected.") print("Valid parsing as Expected.")
for invalid_action_replay_ini in ["a\n082E2CC0 00050096\n","0002E2CC0 00050096","082E2CC0 00050096", "\n122E2CC0 00050096\n"]: for invalid_action_replay_ini in ["a\n082E2CC0 00050096\n","0A02E2CC0 00050096","082E2CC0 00050096", "\n122E2CC0 00050096\n"]:
try: try:
(ini_path / "test2.ini").write_text(invalid_action_replay_ini) (ini_path / "test2.ini").write_text(invalid_action_replay_ini)
parse_action_replay_ini(ini_path / "test2.ini") parse_action_replay_ini(ini_path / "test2.ini")
@ -697,7 +705,6 @@ for index, (overlap0, overlap1) in enumerate(overlaps0):
raise Exception("Error - Invalid get_overlapping_arcodes result.") raise Exception("Error - Invalid get_overlapping_arcodes result.")
print("Testing get_unmapped_intervals.") print("Testing get_unmapped_intervals.")
merged_memo_res = [[ # Testing all limits 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([50,75],[100,200],[250,260],[270,280],[300,400]),
create_memory_objects_from_intervals( create_memory_objects_from_intervals(
@ -976,22 +983,22 @@ intervals_list.append([[156, 160, b"\x66"], [255, 289, b"\x99"], [160, 164, b"\x
# [288, 320], [320, 352], [352, 384], [384, 416], [416, 448] # [288, 320], [320, 352], [352, 384], [384, 416], [416, 448]
intervals_list.append([ intervals_list.append([
[24, 64, b"\x11"], # overlap left match right [24, 64, b"\x11"], # overlap left match right
[96, 130, b"\x11"], # overlap right match left [96, 130, b"\x22"], # overlap right match left
[120, 170, b"\x11"], # overlap left and right [120, 170, b"\x33"], # overlap left and right
[191, 225, b"\x11"], # overlap left and right +1-1 [191, 225, b"\x44"], # overlap left and right +1-1
[255, 353, b"\x11"]]) # overlap left and right +- 3 sections (reversed) [255, 353, b"\x55"]]) # overlap left and right +- 3 sections (reversed)
intervals_list.append([ # same but reverse sorted intervals_list.append([ # same but reverse sorted
[255, 353, b"\x11"], # overlap left and right +- 3 sections (reversed) [255, 353, b"\x11"], # overlap left and right +- 3 sections (reversed)
[191, 225, b"\x11"], # overlap left and right +1-1 [191, 225, b"\x22"], # overlap left and right +1-1
[120, 170, b"\x11"], # overlap left and right [120, 170, b"\x33"], # overlap left and right
[96, 130, b"\x11"], # overlap right match left [96, 130, b"\x44"], # overlap right match left
[24, 64, b"\x11"]]) # overlap left match right [24, 64, b"\x55"]]) # overlap left match right
intervals_list.append([ # same but shuffled intervals_list.append([ # same but shuffled
[120, 170, b"\x11"], # overlap left and right [120, 170, b"\x11"], # overlap left and right
[255, 353, b"\x11"], # overlap left and right +- 3 sections (reversed) [255, 353, b"\x22"], # overlap left and right +- 3 sections (reversed)
[96, 130, b"\x11"], # overlap right match left [96, 130, b"\x33"], # overlap right match left
[24, 64, b"\x11"], # overlap left match right [24, 64, b"\x44"], # overlap left match right
[191, 225, b"\x11"]]) # overlap left and right +1-1 [191, 225, b"\x55"]]) # overlap left and right +1-1
# total file patch # total file patch
# overlap right (match left) 3 sections dol1 <- sorted # overlap right (match left) 3 sections dol1 <- sorted
# overlap left match right 3 sections dol3 <- reverse sorted # overlap left match right 3 sections dol3 <- reverse sorted
@ -1001,6 +1008,8 @@ intervals_list.append([[0, 448, b"\x11"]])
intervals_list.append([[254, 448, b"\x11"]]) intervals_list.append([[254, 448, b"\x11"]])
# overlap left and right +-3 sections <- dol2 1st section # overlap left and right +-3 sections <- dol2 1st section
intervals_list.append([[100, 340, b"\x11"]]) 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"), [ dol123_datas = b"".join(list(map(lambda x: x.to_bytes(4, "big"), [
@ -1035,6 +1044,7 @@ def test_dols(range_dols, intervals_list:list):
doltool_par(dol_tests_path / dol_path, dol_tests_path / dol_patched_path, ini_path / dol_ini_path) 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(): if dol_header + dol_datas != (dol_tests_path / dol_patched_path).read_bytes():
print(interval_index, intervals)
raise Exception("Error - Invalid -par result.") raise Exception("Error - Invalid -par result.")
test_dols(range(1,7), intervals_list) test_dols(range(1,7), intervals_list)
# Testing Overflowing at the end of section + 1 # Testing Overflowing at the end of section + 1
@ -1045,9 +1055,11 @@ 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"], [33, 63, b"\x22"]])
intervals_list.append([[447, 451, b"\x11"]]) intervals_list.append([[447, 451, b"\x11"]])
intervals_list.append([[445, 449, 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 interval_index, intervals in enumerate(intervals_list):
for dol_index in range(1,7): for dol_index in range(1,7):
try: try:
dol_ini_path = f"dol{dol_index}_{interval_index}_exception.ini" dol_ini_path = f"dol{dol_index}_{interval_index}_exception.ini"