170 lines
15 KiB
Python
170 lines
15 KiB
Python
"""Small campaign scenarios over the same reviewed Session; no historical runner copy."""
|
|
import re,time
|
|
from PIL import ImageChops
|
|
from engine import *
|
|
from geometry import *
|
|
|
|
def init_reference(s,prefix_fillers=1):
|
|
s.cmd('workspace 2');s.launch_client('reference','static-reference');rid=s.find('reference')['id'];s.cmd(f'[con_id={rid}] border none')
|
|
s.cmd('workspace 1')
|
|
for i in range(prefix_fillers):s.launch_client('filler'+str(i),'static-reference')
|
|
s.cmd('layout mosaic' if s.spec['mode']=='mosaic' else 'layout splith')
|
|
return rid
|
|
|
|
def stable_reference(s):
|
|
s.inject('move',[s.outputs[0]['logical'][0]+10,s.outputs[0]['logical'][1]+10]);time.sleep(.15)
|
|
a=s.capture('H2-reference1','HEADLESS-2');time.sleep(.6);b=s.capture('H2-reference2','HEADLESS-2');exact(a,b)
|
|
need(all(v==(48,48,56) for v in a.get_flattened_data()),'static uniform H2');s.save('reference-stability',dict(status='PASS',exact=exact(a,b)));return a
|
|
|
|
def root_state(s,state,origin,window_start,expect_hidden=False,previous=None,expected_tree=None):
|
|
# WHY/CONTRACT/INVARIANT: no PI/native scene identity exists in CORE.
|
|
# Pixel/input evidence qualifies sampled clipping only, never generation.
|
|
return dict(status='NOT OBSERVABLE',native_tree_identity='NOT OBSERVABLE',
|
|
applied_generation='NOT OBSERVABLE',owner_id=state['owner']['id'],
|
|
workspace_id=state['workspace']['id'],window=[window_start,time.monotonic_ns()])
|
|
|
|
def open_chain(s,tail_fillers=0):
|
|
|
|
s.cmd('workspace 1');s.cmd('layout mosaic' if s.spec['mode']=='mosaic' else 'layout splith');s.expected_layout='mosaic' if s.spec['mode']=='mosaic' else 'splith'
|
|
pre=s.snapshot('before-chain-'+str(sum(e['kind']=='spawn' and e['name']=='owner' for e in s.events)))
|
|
validators.selected_workspace(pre,'1','HEADLESS-1',s.expected_layout)
|
|
s.debit('chain');s.launch_client('owner',s.spec['client'],s.spec['placement'])
|
|
s.owner('owner') # Reject wrong map before any click; never move mapped popup chains.
|
|
for i in range(tail_fillers):s.launch_client('tail'+str(i),'static-reference')
|
|
s.cmd(f'[con_id={s.find("owner")["id"]}] focus');state=s.calibrate('owner');baseline=s.reference if hasattr(s,'reference') else stable_reference(s);s.reference=baseline
|
|
im=s.capture('owner-top-'+str(sum(e['kind']=='spawn' and e['name']=='owner' for e in s.events)),'HEADLESS-1');rect=[*state['origin'],state['owner']['window_rect']['width'],state['owner']['window_rect']['height']]
|
|
xy=solid_point(im,COLORS['TOPLEVEL'],s.outputs[0],s.frames['HEADLESS-1'],rect)
|
|
need(contains([*state['origin'],420,575 if s.spec['axis']==1 else 320],xy),'opening native bounds')
|
|
ta,ba=s.click('owner',xy,'left',True);s.wait(lambda:'POPUP_A MAP ' in s.log('owner'));time.sleep(.2)
|
|
aim=s.capture('popup-A-'+str(sum(e['kind']=='spawn' and e['name']=='owner' for e in s.events)),'HEADLESS-1');prov=Provenance(state['owner']['id'],state['workspace']['id'],'NOT OBSERVABLE',state['evidence'])
|
|
xyA=solid_point(aim,COLORS['POPUP_A'],s.outputs[0],s.frames['HEADLESS-1'])
|
|
tb,bb=s.click('owner',xyA,'left',True);s.wait(lambda:'POPUP_B MAP ' in s.log('owner'));time.sleep(.2)
|
|
window=time.monotonic_ns();time.sleep(.15);p=validators.grab(s.log('owner'));g=geometry(s.log('owner'),state['origin'],prov,s.spec['axis'],s.spec['boundary'])
|
|
s.delivery('owner',rect,xy,ta,ba,'TOPLEVEL',p['grabs'][0]['serial']);s.delivery('owner',g['A'],xyA,tb,bb,'POPUP_A',p['grabs'][1]['serial'])
|
|
[validators.crosses(g[k],s.spec['axis'],s.spec['boundary']) for k in ('A','B')]
|
|
left,right=s.pair_capture('mapped-'+str(sum(e['kind']=='spawn' and e['name']=='owner' for e in s.events)))
|
|
for name in ('POPUP_A','POPUP_B'):
|
|
need(count(left,COLORS[name])>0,'permitted popup pixels missing')
|
|
if s.spec['mode']=='pristine':need(count(right,COLORS[name])>0,'standard popup continuation missing')
|
|
if s.spec['mode']=='mosaic':validators.rgb(baseline,right);root=root_state(s,state,state['origin'],window)
|
|
else:root=dict(status='NOT OBSERVABLE',meaning='unmodified control has no private clip instrumentation')
|
|
s.save('chain',dict(protocol=p,geometry=g,state=state,root=root,H2_exact=s.spec['mode']=='mosaic',color_counts={n:[count(left,c),count(right,c)] for n,c in COLORS.items()}))
|
|
return state,baseline,p,g,left,right
|
|
|
|
def popup_campaign(s):
|
|
init_reference(s);state,baseline,p,g,left,right=open_chain(s)
|
|
xy=solid_point(left,COLORS['POPUP_B'],s.outputs[0],s.frames['HEADLESS-1'],g['B']);tails,buttons=s.click('owner',xy);s.delivery('owner',g['B'],xy,tails,buttons,'POPUP_B')
|
|
forbidden=intersection(g['B'],s.outputs[1]['logical']);need(forbidden[2]>6 and forbidden[3]>6,'H2 crossing interior missing')
|
|
xy=[forbidden[0]+forbidden[2]//2,forbidden[1]+forbidden[3]//2]
|
|
if s.spec['mode']=='pristine':
|
|
# The point must be real standard paint, not just a requested extent.
|
|
xy=solid_point(right,COLORS['POPUP_B'],s.outputs[1],s.frames['HEADLESS-2'],g['B']);tails,buttons=s.click('owner',xy);s.delivery('owner',g['B'],xy,tails,buttons,'POPUP_B')
|
|
else:
|
|
tails,buttons=s.click('owner',xy);ds=dismissal(tails['owner'],buttons['owner']);s.save('dismissal',dict(proof=ds,reference_buttons=buttons.get('reference'),interpretation='outside grab dismissal; no universal click-through claim'))
|
|
need(not any('target=POPUP_A ' in l or 'target=POPUP_B ' in l for v in buttons.values() for l in v),'forbidden popup delivery')
|
|
s.close_client('owner');time.sleep(.2);final=s.pair_capture('final');exact(baseline,final[1]);need(not any(count(im,COLORS[n]) for im in final for n in ('POPUP_A','POPUP_B')),'popup residual')
|
|
return 'PARTIALLY_FEASIBLE'
|
|
|
|
def hidden_campaign(s):
|
|
init_reference(s,2);state,baseline,p,g,left,right=open_chain(s,2)
|
|
xy=solid_point(left,COLORS['POPUP_B'],s.outputs[0],'logical',g['B']);tails,buttons=s.click('owner',xy);s.delivery('owner',g['B'],xy,tails,buttons,'POPUP_B')
|
|
delta=state['scene'][0]+state['scene'][2]-s.outputs[0]['logical'][0]+16;start=time.monotonic_ns();s.scroll('owner',delta);hidden=s.owner('owner')
|
|
need(intersection(hidden['scene'],s.outputs[0]['logical'])[2]==0,'owner not completely hidden')
|
|
images=s.pair_capture('fully-hidden');need(not any(count(im,COLORS[n]) for im in images for n in ('POPUP_A','POPUP_B')),'hidden popup residual');exact(baseline,images[1])
|
|
root=root_state(s,hidden,hidden['origin'],start,True,previous=state);cut=len(s.log('owner'));s.inject('move',[-790,590]);need('target=POPUP_A ' not in s.log('owner')[cut:] and 'target=POPUP_B ' not in s.log('owner')[cut:],'hidden popup pointer enter')
|
|
validators.hidden_survival(s.log('owner'),p,[])
|
|
return_start=time.monotonic_ns();s.scroll('owner',-delta);restored=s.owner('owner');need(restored['origin']==state['origin'],'same owner origin restored')
|
|
images=s.pair_capture('returned');validators.hidden_survival(s.log('owner'),p,[e for e in s.events if e['kind']=='injection' and start<=e['ns']<=return_start]);exact(baseline,images[1]);returned_root=root_state(s,restored,restored['origin'],return_start,previous=hidden,expected_tree=root.get('tree'));fresh=validators.grab(s.log('owner'));need(fresh['ids']==p['ids'] and fresh['grabs']==p['grabs'],'unchanged live chain')
|
|
g=geometry(s.log('owner'),restored['origin'],Provenance(restored['owner']['id'],restored['workspace']['id'],'NOT OBSERVABLE','fresh return geometry'));xy=solid_point(images[0],COLORS['POPUP_B'],s.outputs[0],'logical',g['B']);tails,buttons=s.click('owner',xy);s.delivery('owner',g['B'],xy,tails,buttons,'POPUP_B')
|
|
s.save('hidden-return',dict(status='PASS',hidden=hidden,empty_root=root,returned=restored,returned_root=returned_root,ids=p['ids']))
|
|
s.close_client('owner');final=s.pair_capture('final');exact(baseline,final[1]);return 'PARTIALLY_FEASIBLE'
|
|
|
|
def sample_surviving(s,images,tag):
|
|
if 'POPUP_DONE ' in s.log('owner'):
|
|
s.save(tag+'-input',dict(status='NOT_EXERCISED',reason='legitimate popup dismissal, no new chain reserved'));return
|
|
state=s.owner('owner');prot=validators.grab(s.log('owner'));geo=geometry(s.log('owner'),state['origin'],Provenance(state['owner']['id'],state['workspace']['id'],'NOT OBSERVABLE','mutation paint+pointer'))
|
|
index=next(i for i,o in enumerate(s.outputs) if o['name']==state['workspace']['output'])
|
|
try:point=solid_point(images[index],COLORS['POPUP_B'],s.outputs[index],s.frames[s.outputs[index]['name']],geo['B'])
|
|
except ValueError:
|
|
s.save(tag+'-input',dict(status='NOT_EXERCISED',reason='B has no measured visible interior'));return
|
|
tails,buttons=s.click('owner',point);s.delivery('owner',geo['B'],point,tails,buttons,'POPUP_B');s.save(tag+'-input',dict(status='PASS',point=point,protocol=prot))
|
|
|
|
def dynamic_geometry(snap,previous=None,mutation="resize"):
|
|
# WHY: scroll IPC alone does not demonstrate the resize clamp.
|
|
# CONTRACT: pinned arrange.c105-131 / mosaic.c125-153, zero inner gap,
|
|
# three direct tiled children; calloc row state has no minimum-width setter
|
|
# and uses640. Corroborate that minimum with every actual IPC child width.
|
|
# INVARIANT: this is a pending IPC candidate, never native applied geometry.
|
|
ws=workspace(snap['tree'],'1');row=ws['mosaic']['rows'][0]
|
|
children=ws['nodes'];ids=[c['id'] for c in children]
|
|
need(len(children)==3 and row['children']==ids,'dynamic direct row reconstruction')
|
|
viewport=[ws['rect'][k] for k in ('x','y','width','height')]
|
|
width=viewport[2];need(0<width<3*640,'dynamic minimum not distinguishable from fitting')
|
|
need(all(c['rect']['width']==640 for c in children),'actual minimum-width reconstruction')
|
|
need([c['rect']['x'] for c in children]==[viewport[0]+i*640 for i in range(3)],'actual zero-gap row reconstruction')
|
|
maximum=3*640-width;scroll=row['scroll_x'];need(0<=scroll<=maximum,'dynamic camera outside clamp')
|
|
result=dict(workspace_id=ws['id'],output=ws['output'],children=ids,viewport=viewport,
|
|
minimum_width=640,content_width=1920,max_scroll=maximum,scroll=scroll,
|
|
geometry_status='IPC_PENDING_CANDIDATE; native generation NOT OBSERVABLE')
|
|
if previous is not None:
|
|
need(ws['id']==previous['workspace_id'] and ids==previous['children'],'dynamic workspace/order changed')
|
|
# WHY: move.c661/668 refocuses after migration; seat.c1204-1212
|
|
# reveals the focused logical cell after the ordinary resize clamp.
|
|
# CONTRACT/INVARIANT: never conflate refocus with resize-only clamp.
|
|
expected=max(0,min(previous['scroll'],maximum))
|
|
need(mutation in ('resize','migration'),'unknown camera mutation')
|
|
if mutation=='migration':
|
|
focused=[c for c in children if c.get('focused')]
|
|
need(len(focused)==1,'migration exact focused direct child required')
|
|
lo=ids.index(focused[0]['id'])*640;hi=lo+640
|
|
if lo<expected:expected=lo
|
|
elif hi>expected+width:expected=hi-width
|
|
expected=max(0,min(expected,maximum))
|
|
need(scroll==expected,'reconstructed camera '+mutation+' mismatch')
|
|
result.update(expected_scroll=expected,clamp='PASS',mutation=mutation)
|
|
return result
|
|
|
|
def dynamic_pixels(images,outputs,frames,viewport,reference=None):
|
|
# WHY/CONTRACT: each mutation must reject old-output and outside-clip paint.
|
|
# INVARIANT: sampled RGB exclusion cannot prove complete native damage.
|
|
for image,out in zip(images,outputs):
|
|
for y in range(image.height):
|
|
for x in range(image.width):
|
|
if image.getpixel((x,y)) in (COLORS['POPUP_A'],COLORS['POPUP_B']):
|
|
need(contains(viewport,png_global((x,y),out,frames[out['name']])),'dynamic popup pixel outside current viewport')
|
|
if reference is not None:exact(reference,images[1])
|
|
return dict(exclusion='PASS',whole_H2='PASS' if reference is not None else 'NOT_APPLICABLE: current owner workspace on H2',complete_damage='NOT OBSERVABLE')
|
|
|
|
def dynamic_campaign(s):
|
|
init_reference(s,2);s.cmd('gaps inner 0');state,baseline,p,g,left,right=open_chain(s)
|
|
owner_id=state['owner']['id'];previous=dynamic_geometry(state['snapshot']);stages=[]
|
|
mutations=[('output HEADLESS-1 resolution 960x600 position -960 0','resized960','HEADLESS-1'),
|
|
('output HEADLESS-1 resolution 800x600 position -800 0','resized-back','HEADLESS-1'),
|
|
('move workspace to output HEADLESS-2','migrated-H2','HEADLESS-2'),
|
|
('move workspace to output HEADLESS-1','migrated-back-H1','HEADLESS-1')]
|
|
for command,tag,out in mutations:
|
|
s.cmd('workspace 1');s.cmd(command,True);s.expected_output=out
|
|
if tag=='resized960':s.outputs[0]={**s.outputs[0],'logical':[-960,0,960,600],'mode':[960,600]}
|
|
elif tag=='resized-back':s.outputs[0]=dict(s.spec['outputs'][0])
|
|
time.sleep(.35);snap=s.snapshot(tag);current=dynamic_geometry(snap,previous,"migration" if tag.startswith("migrated") else "resize")
|
|
need(current['output']==out and s.find('owner')['id']==owner_id,'dynamic exact owner/output')
|
|
expected_viewport=next(o['logical'] for o in s.outputs if o['name']==out)
|
|
need(current['viewport']==expected_viewport,'dynamic viewport/output reconstruction')
|
|
pictures=s.pair_capture(tag)
|
|
pixels=dynamic_pixels(pictures,s.outputs,s.frames,current['viewport'],baseline if out=='HEADLESS-1' else None)
|
|
# An alive chain must supply fresh paint and local pointer input; an
|
|
# actual XDG dismissal is recorded without injecting on destroyed popups.
|
|
if 'POPUP_DONE ' not in s.log('owner'):
|
|
fresh=s.owner('owner');geo=geometry(s.log('owner'),fresh['origin'],Provenance(owner_id,current['workspace_id'],'NOT OBSERVABLE','fresh mutation IPC + paint + pointer'))
|
|
index=next(i for i,o in enumerate(s.outputs) if o['name']==out)
|
|
point=solid_point(pictures[index],COLORS['POPUP_B'],s.outputs[index],s.frames[out],geo['B'])
|
|
tails,buttons=s.click('owner',point);s.delivery('owner',geo['B'],point,tails,buttons,'POPUP_B')
|
|
need(validators.grab(s.log('owner'))['ids']==p['ids'],'dynamic popup IDs changed')
|
|
input_proof=dict(status='PASS',point=point)
|
|
else:input_proof=dict(status='NOT_EXERCISED',reason='XDG dismissal; no injection on destroyed popup')
|
|
stages.append(dict(tag=tag,geometry=current,pixels=pixels,input=input_proof));previous=current
|
|
s.save('dynamic-ownership',dict(status='PASS',stages=stages,ids_before=p['ids'],atomic_generation='NOT PROVEN',complete_damage='NOT OBSERVABLE'))
|
|
s.close_client('owner')
|
|
for name in list(s.proc):
|
|
if name.startswith('filler'):s.close_client(name,'close')
|
|
s.save('dynamic-final-limit',dict(status='NOT_TESTED',reason='14 capture cap used by opening and four fresh mutation states; no post-close capture'));return 'PARTIALLY_FEASIBLE'
|