Files
horizon-airdef/tools/test_stored_effect_notifications_parity.py
T
Ludovic Marie fdae4b895c horizon-world probes: one binary, probe <name>
The 168 horizon-world examples the parity harnesses run become modules of
one example, examples/probe, that dispatches on its first argument;
crate::args() gives each the command line its example saw. Linking ~170
binaries, each instantiating horizon-world's generics again, was most of
the parity job's probe build (review plan, section 1).

The harnesses build `--example probe` and run `probe <name> ...`.
tools/parity.py counts only the probes a harness ran, and the support
modules they name, as its dependencies, so editing one probe still reruns
only its own harnesses (and PARITY_RUST_SCOPE keeps working).

The six manual tools (benches, loot_fill, structure_blocks, vanilla_diff,
attribute_memory, behaviour_load_profile) stay separate examples.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 16:30:38 +02:00

93 lines
7.5 KiB
Python

#!/usr/bin/env python3
"""Compare entity effect notifications with real stored attributes and native pending refresh."""
import argparse
import json
import os
from pathlib import Path
import platform
import subprocess
import random
import struct
try:
from . import lab, test_rust_parity as base, test_stored_effect_attributes_parity as stored_base
except ImportError:
import lab
import test_rust_parity as base
import test_stored_effect_attributes_parity as stored_base
def corpus():
rows=list(stored_base.corpus())
yield from rows
def op(kind, **kw):
r=dict(op=kind,key=0,instance=0,template=0,target=0,amplifier=0,flag=False,value='0000000000000000',
fail=-1,mutate=-1,mutations=[],client=False,reapply=True,count=1)
r.update(kw);return r
selected=[rows[i] for i in [0,4,8,12,18,22,36,50]]
for row in selected:
for client in [False,True]:
for reapply in [False,True]:
for count in [0,1,3]:
yield dict(row,ops=[op('get'),op('dirty'),op('notify-add',client=client),op('value'),
op('notify-update',amplifier=4,reapply=reapply,client=client),op('value'),
op('notify-remove',count=count,client=client),op('refresh'),op('value')])
actions=[[op('queue-clear')],[op('queue-add',instance=-1)],[op('queue-drop',instance=0)],
[op('queue-add',target=1,instance=-1)],[op('clear')],[op('put',instance=0)],
[op('drop')],[op('syncable',flag=False)],[op('syncable',flag=True)]]
for row in selected[:5]:
for kind in ['notify-add','notify-update','notify-remove','refresh']:
for fail in range(12):
yield dict(row,ops=[op('get'),op('notify-add'),op('dirty'),op(kind,fail=fail),op('value'),op('refresh'),op('notify-remove')])
for mutations in actions:
for at in [0,1,2,3,5]:
yield dict(row,ops=[op('get'),op('notify-add'),op('dirty'),op(kind,mutate=at,mutations=mutations),op('value'),op('refresh'),op('notify-remove')])
rng=random.Random(0x53544f524e4f54)
for _ in range(150):
row=rng.choice(selected)
ops=[op('get')]
for __ in range(20):
kind=rng.choice(['notify-add','notify-update','notify-remove','refresh','dirty','value','queue-clear'])
ops.append(op(kind,client=rng.randrange(7)==0,reapply=bool(rng.randrange(2)),count=rng.randrange(4),
amplifier=rng.choice([-2**31,-1,0,1,255,256,2**31-1]),flag=bool(rng.randrange(2)),
fail=rng.choice([-1,-1,-1,0,1,3,5]),mutate=rng.choice([-1,-1,0,1,2,3,5]),mutations=rng.choice(actions)))
yield dict(row,ops=ops)
def main():
parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--prepare',action='store_true');args=parser.parse_args()
build=lab.LOCAL/'rust-stored-effect-notifications-parity';build.mkdir(parents=True,exist_ok=True)
report_path=build/'report.json';report_path.unlink(missing_ok=True)
if args.prepare:lab.prepare()
lock,jars,libraries=base.verify_artifacts()
oracle=lab.ROOT/'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaStoredEffectNotificationsOracle.java'
sources=[oracle,Path(__file__),lab.ROOT/'tools/test_rust_parity.py',lab.ROOT/'tools/lab.py',lab.ROOT/'Cargo.toml',lab.ROOT/'Cargo.lock',lab.ROOT/'crates/horizon-core/Cargo.toml',lab.ROOT/'crates/horizon-world/Cargo.toml',*sorted((lab.ROOT/'crates/horizon-core/src').rglob('*.rs')),*sorted((lab.ROOT/'crates/horizon-world/src').rglob('*.rs')),lab.ROOT/'crates/horizon-world/examples/probe/stored_effect_notifications_fixture.rs']
helper=lab.ROOT/'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaStoredEffectAttributesOracle.java'
sources.extend([helper,lab.ROOT/'crates/horizon-world/examples/probe/stored_effect_attributes_fixture.rs',lab.ROOT/'tools/test_stored_effect_attributes_parity.py'])
tested_sources=base.source_hashes(sources)
classes=build/'classes';classes.mkdir(exist_ok=True)
def run(command,name):
with (build/(name+'.log')).open('w',encoding='utf-8') as log:base.run(list(map(str,command)),stdout=log,stderr=subprocess.STDOUT)
dependency_path=os.pathsep.join(map(str,libraries))
run(['javac','--release',lock['minecraft']['java_major'],'-proc:none','-sourcepath',str(lab.ROOT/'mods/horizon/src/test/java'),'-cp',str(jars['server'])+os.pathsep+dependency_path,'-d',classes,oracle,helper],'compile-java')
def java(side,mode,path):
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.VanillaStoredEffectNotificationsOracle',mode,path],side+'-'+mode)
fixtures=list(corpus());inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
references=[]
for side,jar in jars.items():
java(side,side,build)
enriched=build/f'inputs-{side}.txt';fixture_paths.append(enriched);tested_fixtures.update(base.source_hashes([enriched]))
run([binary,'stored_effect_notifications_fixture',build,side],'rust-'+side)
reference=build/f'{side}.txt';candidate=build/f'rust-{side}.txt';matched=base.compare(reference,candidate)
references.append({'side':side,'jar_sha256':lab.digest(jar,'sha256'),'output_sha256':lab.digest(reference,'sha256'),'matched_output_lines':matched,'rust_output_sha256':lab.digest(candidate,'sha256')})
print(f'{side}: {matched:,} stored effect notification output lines match Rust',flush=True)
base.ensure_sources_unchanged(sources,tested_sources);base.ensure_sources_unchanged(fixture_paths,tested_fixtures)
report={'schema':1,'minecraft':lock['minecraft']['version'],'manifest_sha1':lock['minecraft']['manifest_sha1'],'platform':platform.platform(),'java':subprocess.check_output(['java','--version'],text=True).splitlines()[0],'rustc':subprocess.check_output(['rustc','--version'],text=True).strip(),'fixtures':len(fixtures),'fastutil_sha256':{str(p.relative_to(lab.ROOT)):lab.digest(p,'sha256') for p in libraries if 'fastutil' in str(p)},'sources_sha256':tested_sources,'fixtures_sha256':tested_fixtures,'references':references,'scope':'Inherited LivingEntity onEffectAdded/onEffectUpdated/onEffectsRemoved and private refreshDirtyAttributes, with actual MobEffect modifier bodies, AttributeMap.getInstance, AttributeSupplier.createInstance, AttributeInstance storage and native pending update/sync sets. Includes complete stored-attribute corpus plus client guards, effect dirty state, reapply/empty removal, refresh failure prefixes and callback map/queue mutation. Actual JVM identity hashes replayed separately in Rust. Virtual onAttributeUpdated consequence, basic attribute default/syncability methods and level client flag are controlled; passenger lists are empty (packet paths have separate gates). Registered definitions, combined health/dimension consequences, full entity lifecycle/gameplay and platform builds remain pending.'}
lab.write_json(report_path,report);print(f'Scoped stored effect notification parity passed: {report_path}')
if __name__=='__main__':main()