79 lines
4.9 KiB
Python
79 lines
4.9 KiB
Python
"""Original body mode/landing phase guards and retained native observations."""
|
|
from pathlib import Path
|
|
import hashlib,json,sys,tempfile,unittest
|
|
ROOT=Path(__file__).resolve().parents[1]
|
|
sys.path.insert(0,str(ROOT/'tools/binary'))
|
|
from body_modes import collect,generate
|
|
|
|
class BodyModeEvidence(unittest.TestCase):
|
|
def fixture(self):
|
|
return json.loads((ROOT/'tests/body-modes-reference.json').read_text())
|
|
|
|
def test_original_source_and_provenance(self):
|
|
fixture=self.fixture();source=collect(ROOT.parent/'Original')
|
|
for key in ('sha256','bodies','probe_operands','rea_evidence_id','flag_slots','scope'):
|
|
self.assertEqual(source[key],fixture['source'][key])
|
|
for row in source['bodies']:
|
|
self.assertEqual(int(row['file_offset'],16),int(row['va'],16)-0x400000)
|
|
for file,digest in fixture['files'].items():
|
|
self.assertEqual(len(digest),64)
|
|
if file.startswith('tools/'):
|
|
self.assertEqual(hashlib.sha256((ROOT/file).read_bytes()).hexdigest(),digest)
|
|
self.assertEqual(len(fixture['cases']),87)
|
|
|
|
def test_all_sixty_four_original_flag_combinations(self):
|
|
cases={c['name']:c for c in self.fixture()['cases']}
|
|
for bits in range(64):
|
|
c=cases[f'flags_{bits:02}'];f=c['flags'];o=c['observed'];calls=o['calls']
|
|
integrate=f['integration'];collision=f['collision'];world=f['world_response'];support=f['support'];geometry=f['geometry']
|
|
self.assertEqual(calls[0],int(integrate and collision and world))
|
|
self.assertEqual(calls[1],int(integrate and ((collision and not world) or (not collision and not f['alternate']))))
|
|
self.assertEqual(calls[2],int(integrate and collision))
|
|
self.assertEqual(calls[3],int(integrate and collision and world))
|
|
self.assertEqual(calls[4],1+int(integrate and collision))
|
|
self.assertEqual(calls[5],int(integrate and collision and (not support or not geometry)))
|
|
self.assertEqual(calls[6],int(integrate and collision and support and geometry))
|
|
self.assertEqual(calls[7],int(integrate));self.assertEqual(calls[8],int(integrate))
|
|
self.assertEqual(o['supported'],int(not support if not integrate else not geometry or not support))
|
|
reset=integrate and collision and world
|
|
self.assertEqual(o['context'],[0,130000,60,0] if reset else [0x11111111,1234,5678,0x22222222])
|
|
if not integrate:
|
|
self.assertEqual(o['impulse'],[0,20,0]);self.assertEqual(o['velocity'],[100,200,50])
|
|
self.assertEqual(o['events'],'GSFI' if support else 'GSI')
|
|
else:
|
|
self.assertLess(o['events'].index('R'),o['events'].index('Q'))
|
|
self.assertLess(o['events'].index('Q'),o['events'].index('C'))
|
|
|
|
def test_callback_mutation_and_suppression_observations(self):
|
|
cases={c['name']:c['observed'] for c in self.fixture()['cases']}
|
|
self.assertEqual(cases['world_mutation_1']['calls'][6],0)
|
|
self.assertEqual(cases['world_mutation_5']['acceleration'],[0,0,0])
|
|
self.assertLess(cases['world_mutation_5']['velocity'][1],-200)
|
|
for index in (2,3,4):
|
|
c=cases[f'world_mutation_{index}'];self.assertEqual(c['calls'][0],1);self.assertEqual(c['calls'][5],1)
|
|
for index in range(10,21):self.assertEqual(cases[f'landing_mutation_{index}']['landings'],1)
|
|
normal=cases['landing_mutation_10']
|
|
self.assertEqual(cases['landing_mutation_14']['velocity'],normal['velocity'])
|
|
self.assertEqual(cases['landing_mutation_15']['acceleration'],[7,123,9])
|
|
self.assertEqual(cases['landing_mutation_16']['position'],[77,88,99,2])
|
|
self.assertEqual(cases['landing_mutation_17']['impulse'],[7,123,9])
|
|
self.assertEqual(cases['landing_mutation_18']['anchor'],[7,123,9])
|
|
self.assertEqual(cases['landing_mutation_20']['supported'],1)
|
|
self.assertEqual(cases['landing_mutation_12']['calls'][5],0)
|
|
self.assertEqual(cases['landing_mutation_12']['speed'],100)
|
|
for name in ('world_off_below_floor','collision_off_below_floor'):
|
|
self.assertLess(cases[name]['position'][1],-25000)
|
|
for name in ('collision_off_linear_suppression','frozen_linear_suppression'):
|
|
self.assertEqual(cases[name]['velocity'],[0,0,0]);self.assertEqual(cases[name]['angular'],[0,0,0])
|
|
self.assertGreater(cases[name]['rotation'][1],0)
|
|
|
|
def test_generated_output_separation(self):
|
|
original=ROOT.parent/'Original'
|
|
for output in (original,original/'generated',ROOT.parent):
|
|
with self.assertRaises(ValueError):generate(original,output)
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
output=Path(directory);(output/'body_modes_probe.c').symlink_to(original/'Neutron.exe')
|
|
with self.assertRaises(ValueError):generate(original,output)
|
|
|
|
if __name__=='__main__':unittest.main()
|