Software test cases
Canonical specifications at the software verification level. Each case retains its own Need ID, requirement links and execution history. See Test-case specification for classification and evidence semantics.
STV_TC_SW_001: reverse traversal has no depth cutoff
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. test('STV_SWR_006 STV_SWR_013: reverse traversal has no depth cutoff', () => {
const g = graph(Array.from({length:8},(_,i)=>[String(i),'r',String(i+1)]));
let s=initial(['8']); for(let i=8;i>0;i--) s=toggle(g,s,String(i),'incoming');
assert.equal(visible(g,s).ids.length,9); assert.equal(visible(g,s).edges.length,8);
s=initial(['0']);for(let i=0;i<8;i++)s=toggle(g,s,String(i));
assert.equal(visible(g,s).ids.length,9);
});
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_002: parent and project center over five visible children
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. test('STV_SWR_056: parent and project center over five visible children',async()=>{
const ids=['P','A','B','C','D','E'];
const graph={model:{levels:['parent','child'],types:{p:{level:'parent'},c:{level:'child'}}},objects:Object.fromEntries(ids.map(id=>[id,{type:id==='P'?'p':'c'}]))};
const result=await compute(graph,{ids,edges:ids.slice(1).map(id=>[id,'r','P']),project:true,entries:['P']},new Map());
const parent=result.nodes.get(key('P')),children=ids.slice(1).map(id=>result.nodes.get(key(id)));
const middle=(Math.min(...children.map(n=>n.x))+Math.max(...children.map(n=>n.x+n.width)))/2;
assert.equal(parent.x+parent.width/2,middle);
const project=result.nodes.get(JSON.stringify(['project']));assert.equal(project.x,parent.x);
});
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_003: page boundaries, root capacity and independent views
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. test('STV_SWR_051 STV_SWR_052 STV_SWR_043 STV_SWR_044: page boundaries, root capacity and independent views',()=> {
for(const size of [0,1,5,6,199,200,201]) {
const entries=Array.from({length:size},(_,i)=>String(i).padStart(3,'0')),g=graph([],entries),fresh=initial();
const opened=transition(g,fresh,{type:'root'});
if(!size){assert.equal(opened.state,fresh);assert.match(opened.error,/No stakeholder/);continue;}
let s=fresh;const seen=[];
for(let page=0;page<Math.ceil(size/5);page++) {s=transition(g,s,{type:'page',page}).state;seen.push(...visible(g,s).entries);assert.ok(visible(g,s).ids.length<=5);}
assert.deepEqual(seen,entries);assert.equal(fresh.rootOpen,true);
const rejected=transition(g,s,{type:'page',page:Math.ceil(size/5)});assert.equal(rejected.state,s);
}
for(const total of [199,200,201]) {
const entries=['A'],g=graph(Array.from({length:total-2},(_,i)=>['A','r','child'+i]),entries);
const s=initial();
const result=transition(g,s,{type:'group',id:'A',relation:'r',direction:'outgoing'});
if(total<=200)assert.equal(result.graph.ids.length+1,total);else assert.equal(result.state,s);
}
});
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_006: self-loop terminates and collapse restores the only seed
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. test('STV_SWR_024: self-loop terminates and collapse restores the only seed',()=> {
const g=graph([['A','r','A']]);let s=toggle(g,initial(['A']),'A');
assert.deepEqual(visible(g,s).ids,['A']);assert.equal(visible(g,s).edges.length,1);
s=toggle(g,s,'A');assert.equal(visible(g,s).edges.length,0);
});
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_007: replacement level mappings drive ordering without relation-name assumptions
Test case: replacement level mappings drive ordering without relation-name assumptions STV_TC_SW_007
|
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. test('STV_SWR_055: replacement level mappings drive ordering without relation-name assumptions',()=> {
const graph={model:{levels:['hardware','software'],types:{h:{level:'hardware'},s:{level:'software'}}},
objects:{A:{type:'s'},B:{type:'h'}},adjacency:{A:{outgoing:{custom:['B']},incoming:{same:['A']}}}};
assert.deepEqual(orderedGroups(graph,'A').map(g=>g.relation),['custom','same']);
graph.model.levels.reverse();
assert.deepEqual(orderedGroups(graph,'A').map(g=>g.relation),['same','custom']);
});
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_008: runtime reseeding is atomic and clears exploration
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. test('STV_SWR_057: runtime reseeding is atomic and clears exploration',()=>{
const g=graph([['A','r','B']],['A','B']);g.objects={A:{},B:{}};
let s=toggle(g,initial(),'A');assert.equal(transition(g,s,{type:'seed',id:'unknown'}).state,s);
s=transition(g,s,{type:'seed',id:' B '}).state;assert.deepEqual(visible(g,s).ids,['B']);assert.equal(s.expanded.size,0);
s=transition(g,s,{type:'overview'}).state;assert.equal(s.page,0);assert.deepEqual(visible(g,s).entries,['A','B']);
});
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_009: host normalization
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. def test_host_normalization():
source = deepcopy(MODEL)
model = normalize(TYPES, LINKS, source, True)
assert source == MODEL
assert model["types"]["goal"]["color"] == "#abc"
assert model["types"]["case"]["color"]
assert model["relations"]["verifies"]["incoming"] == "Verified by"
assert model["accepted_statuses"] == ["accepted"]
source["accepted_statuses"] = ["approved"]
assert normalize(TYPES, LINKS, source)["accepted_statuses"] == ["approved"]
assert normalize(list(reversed(TYPES)), LINKS, source)['types']['case']['color']==model['types']['case']['color']
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_010: clear facing ports and fan-in avoid outer detours
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. test('STV_SWR_053: clear facing ports and fan-in avoid outer detours', async()=> {
const graph={model:{levels:['parent','child'],types:{p:{level:'parent'},c:{level:'child'}}},
objects:{P:{type:'p'},A:{type:'c'},B:{type:'c'},C:{type:'c'}}};
const result=await compute(graph,{ids:['P','A','B','C'],edges:[['A','r','P'],['B','r','P'],['P','r','C']]},new Map());
for(const edge of result.edges) {
assert.equal(edge.points.length,2);
const a=result.nodes.get(edge.source),b=result.nodes.get(edge.target);
if(a.y>b.y)assert.deepEqual(edge.points,[[a.x+140,a.y],[b.x+140,b.y+b.height]]);
else assert.deepEqual(edge.points,[[a.x+140,a.y+a.height],[b.x+140,b.y]]);
}
});
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_011: competing parents do not displace a separate centered parent
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. test('STV_SWR_056: competing parents do not displace a separate centered parent',async()=>{
const objects={P:{type:'p'},Q:{type:'p'},R:{type:'p'},...Object.fromEntries(['A','B','C','D','E','F'].map(id=>[id,{type:'c'}]))};
const graph={objects,model:{levels:['p','c'],types:{p:{level:'p'},c:{level:'c'}}}};
const edges=[['P','r','A'],...['Q','R'].flatMap(p=>['B','C','D','E','F'].map(c=>[p,'r',c]))];
const result=await compute(graph,{ids:Object.keys(objects),edges},new Map());
const center=id=>result.nodes.get(key(id)).x+140;
assert.equal(center('P'),center('A'),'a noncompeting parent can remain exactly centered');
const desired=(Math.min(...['B','C','D','E','F'].map(center))+Math.max(...['B','C','D','E','F'].map(center)))/2;
assert.equal((center('Q')+center('R'))/2,desired,'shared-parent displacement balances locally');
assert.equal(Math.abs(center('Q')-center('R')),328);
});
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_012: project pages preserve independent expansion and collapsed root
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. test('STV_SWR_051 STV_SWR_052: project pages preserve independent expansion and collapsed root', () => {
const entries=Array.from({length:201},(_,i)=>String(i).padStart(3,'0'));
const g=graph([['000','r','child'],['005','r','other']],entries);
let s=initial(); assert.equal(visible(g,s).ids.length,5);
s=toggle(g,s,'000');
s=transition(g,s,{type:'page',page:1}).state; assert.ok(!visible(g,s).ids.includes('child'));
s=toggle(g,s,'005'); s=transition(g,s,{type:'page',page:0}).state;
assert.ok(visible(g,s).ids.includes('child')); assert.ok(!visible(g,s).ids.includes('other'));
s=transition(g,s,{type:'root'}).state; assert.equal(visible(g,s).ids.length,0);
s=transition(g,s,{type:'root'}).state; assert.ok(visible(g,s).ids.includes('child'));
const all=[]; for(let page=0;page<41;page++) {s=transition(g,s,{type:'page',page}).state; all.push(...visible(g,s).ids.filter(i=>entries.includes(i)));}
assert.equal(new Set(all).size,201);
assert.notEqual(groupKey('a,b','c','incoming'),groupKey('a','b,c','incoming'));
});
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_013: invalid directional labels
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. def test_invalid_directional_labels(incoming):
with pytest.raises(ValueError,match='needs_links.verifies'):
normalize(TYPES,[dict(LINKS[0],incoming=incoming)],MODEL)
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_014: classic registration treats prototype keys and script text as data
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. def test_classic_registration_treats_prototype_keys_and_script_text_as_data(tmp_path):
graph={'schema':1,'objects':{'__proto__':{'id':'__proto__','title':'</script>\u2028'}},'adjacency':{'__proto__':{'incoming':{},'outgoing':{}}}}
identity,path=emit(graph,{'__proto__':'<p>Published body</p>'},tmp_path)
script=(tmp_path/path).read_text(encoding='utf-8')
assert '</script>' not in script
result=subprocess.run(['node','-e','require(process.argv[1]);const g=Object.values(globalThis.__STV_DATA__.graphs)[0];process.stdout.write(JSON.stringify({ids:Object.keys(g.objects),prototype:Object.getPrototypeOf(g.objects),missing:typeof g.objects.constructor,title:g.objects.__proto__.title}));',str(tmp_path/path)],capture_output=True,text=True,encoding='utf-8')
assert result.returncode==0,result.stderr
data=json.loads(result.stdout)
assert data=={'ids':['__proto__'],'prototype':None,'missing':'undefined','title':graph['objects']['__proto__']['title']}
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_015: rooted diamond and isolated cycle
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. test('STV_SWR_003 STV_SWR_007 STV_SWR_020 STV_SWR_024 STV_SWR_025: rooted diamond and isolated cycle', () => {
const g = graph([['A','r','B'],['A','r','C'],['B','r','D'],['C','r','D'],['D','r','B']]);
let s = initial(['A', 'A', 'Z']);
assert.deepEqual(visible(g,s).ids, ['A','Z']);
for (const id of ['A','B','C','D']) s = toggle(g,s,id);
assert.equal(visible(g,s).ids.filter(i=>i==='D').length,1);
s = toggle(g,s,'B'); assert.ok(visible(g,s).ids.includes('D'));
s = toggle(g,s,'C'); assert.deepEqual(new Set(visible(g,s).ids),new Set(['A','Z','B','C']));
s = toggle(g,s,'A'); assert.deepEqual(visible(g,s).ids,['A','Z']);
s = toggle(g,s,'A'); assert.ok(visible(g,s).ids.includes('B'));
});
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_016: invalid model
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. def test_invalid_model(change, path):
with pytest.raises(ValueError, match=path):
normalize(TYPES, LINKS, dict(MODEL, **change))
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_017: invalid model
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. def test_invalid_model(change, path):
with pytest.raises(ValueError, match=path):
normalize(TYPES, LINKS, dict(MODEL, **change))
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_018: 199/200/201 atomic capacity
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. test('STV_SWR_005 STV_SWR_043 STV_SWR_044: 199/200/201 atomic capacity', () => {
for (const size of [199,200,201]) {
const g = graph(Array.from({length:size-1},(_,i)=>['A','r',String(i)]));
const s = initial(['A']), result = transition(g,s,{type:'group',id:'A',relation:'r',direction:'outgoing'});
if (size <= 200) assert.equal(result.graph.ids.length,size);
else { assert.equal(result.state,s); assert.match(result.error,/200-node/); assert.equal(s.expanded.size,0); }
}
});
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_021: portable paths preserve queries and fragments
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. def test_portable_paths_preserve_queries_and_fragments():
assert portable_url("../images/a.png?v=1#part", "nested/page.html") == "images/a.png?v=1#part"
assert portable_url("#section", "nested/page.html") == "nested/page.html#section"
assert portable_url("../../outside.png", "page.html") is None
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_023: invalid directional labels
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. def test_invalid_directional_labels(incoming):
with pytest.raises(ValueError,match='needs_links.verifies'):
normalize(TYPES,[dict(LINKS[0],incoming=incoming)],MODEL)
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_024: blocked skipped-level edges retain safe detours
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. test('STV_SWR_053: blocked skipped-level edges retain safe detours', async()=> {
const graph={model:{levels:['top','middle','bottom'],types:{t:{level:'top'},m:{level:'middle'},b:{level:'bottom'}}},
objects:{T:{type:'t'},M:{type:'m'},B:{type:'b'}}};
const result=await compute(graph,{ids:['T','M','B'],edges:[['B','r','T'],['T','r','B']]},new Map());
const middle=result.nodes.get(key('M'));
for(const edge of result.edges) {
assert.ok(edge.points.length>2);
for(let i=1;i<edge.points.length;i++) {
const p=edge.points[i-1],q=edge.points[i];
assert.ok(p[0]===q[0]||p[1]===q[1]);
for(let t=.001;t<1;t+=.001) {
const x=p[0]+t*(q[0]-p[0]),y=p[1]+t*(q[1]-p[1]);
assert.ok(!(x>middle.x&&x<middle.x+middle.width&&y>middle.y&&y<middle.y+middle.height));
}
}
}
});
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_025: srcset data images and css resources
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. def test_srcset_data_images_and_css_resources():
markup='''<div style="color:red;background-image:url(../images/local.png)"><img srcset="data:image/png;base64,AAAA 1x, ../images/two.png 2x, https://example.org/three.png 3x"><style>@import "https://example.org/remote.css"; .image {background: url(//example.org/remote.png)}</style></div>'''
result=BeautifulSoup(transform(markup,'nested/page.html',set()),'html.parser')
assert result.div['data-stv-style']=='color:red;background-image:url("images/local.png")'
assert result.img['data-stv-srcset']=='data:image/png;base64,AAAA 1x, images/two.png 2x'
assert '@import' not in result.style.text
assert 'https:' not in result.style.text
assert result.find('a',href='https://example.org/three.png')
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_026: cross-page targets do not acquire synthetic root edges
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. test('STV_SWR_051 STV_SWR_052: cross-page targets do not acquire synthetic root edges',()=> {
const g=graph([['000','r','050']],Array.from({length:51},(_,i)=>String(i).padStart(3,'0')));
let s=initial();s=toggle(g,s,'000');
const v=visible(g,s);assert.ok(v.ids.includes('050'));assert.ok(!v.entries.includes('050'));
assert.equal(v.entries.length,5);
});
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_028: invalid model
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. def test_invalid_model(change, path):
with pytest.raises(ValueError, match=path):
normalize(TYPES, LINKS, dict(MODEL, **change))
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_031: invalid directional labels
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. def test_invalid_directional_labels(incoming):
with pytest.raises(ValueError,match='needs_links.verifies'):
normalize(TYPES,[dict(LINKS[0],incoming=incoming)],MODEL)
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_032: static details and remote fallback
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. def test_static_details_and_remote_fallback():
markup = '''<table id="NEED"><tr><td><b>Rich text</b><script>bad()</script>
<img src="../images/local.png" onerror="bad()"><img src="//example.org/picture.png">
<video poster="https://example.org/poster.png"><source src="https://example.org/movie.mp4"></video>
<svg><use href="https://example.org/symbol.svg#x"/></svg>
<iframe src="https://example.org/widget"></iframe><object data="https://example.org/document"></object>
<span style="background:url(https://example.org/background)">Static widget</span>
<span class="traces"><a href="../other.html#HIDDEN">hidden reference</a></span><a href="javascript:bad()">unsafe</a>
<a href="https://example.org/other.html#HIDDEN">Deliberately published prose reference</a>
<a href="https://example.org/original">Original</a><label for="field">Name</label><input id="field">
</td></tr></table>'''
result = BeautifulSoup(transform(markup, "nested/needs.html", {"HIDDEN"}, {"traces"}), "html.parser")
assert result.find("b").text == "Rich text"
assert "Static widget" in result.text
assert not result.find_all(["script", "iframe", "object"])
assert not result.select("[onerror]")
assert 'https:' not in ''.join(tag.get('style','') for tag in result.find_all(True))
assert "hidden reference" not in result.text
assert 'Deliberately published prose reference' in result.text
assert result.find("img")["data-stv-src"] == "images/local.png"
assert not result.find_all(src=lambda s: s and s.startswith("http"))
assert "Resource unavailable offline" in result.text
assert result.find("a", string="Original")["href"] == "https://example.org/original"
assert not result.find("a", string="unsafe").has_attr("href")
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_033: Concurrent build-scoped detail loading
Level: Software component unit test. Preconditions: Pinned frontend dependencies and Node; a controlled document/script stub supplies local asset load events and fragment registration. Executable selector: Invocation: Procedure and expected outcomes: One script is appended for concurrent requests. Both calls share a promise and return the registered HTML. A new build identity loads its own fragment rather than reusing stale HTML. Evidence: Retain per-case Node output and candidate identity for release qualification. Routine refactor checks do not create a release record or change this canonical latest-result field. |
STV_TC_SW_034: Retry local detail loading after failure
Level: Software component unit test. Preconditions: Pinned frontend dependencies and Node; a controlled document/script stub supplies local asset load events and fragment registration. Executable selector: Invocation: Procedure and expected outcomes: A failed asset rejects and removes its script. Retrying creates a fresh script/promise and resolves the newly registered fragment. Evidence: Retain per-case Node output and candidate identity for release qualification. Routine refactor checks do not create a release record or change this canonical latest-result field. |
STV_TC_SW_036: local suggestions match IDs and titles and bound results
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. test('STV_SWR_057: local suggestions match IDs and titles and bound results',()=>{
const catalog=seedCatalog({objects:Object.fromEntries(Array.from({length:15},(_,i)=>['ID_'+i,{title:'Example '+i}]))});
assert.equal(seedMatches(catalog,' example ').total,15);
assert.equal(seedMatches(catalog,'example').items.length,10);
assert.equal(seedMatches(catalog,'id_14').items[0].id,'ID_14');
assert.equal(seedMatches(catalog,'').total,0);
assert.equal(seedMatches(catalog,'hidden').total,0);
});
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_037: invalid directional labels
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. def test_invalid_directional_labels(incoming):
with pytest.raises(ValueError,match='needs_links.verifies'):
normalize(TYPES,[dict(LINKS[0],incoming=incoming)],MODEL)
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_038: invalid model
Level: Software component unit test. Preconditions and inputs: Use the pinned implementation environment, fixture setup and parameter variant identified by the executable selector. Browser cases require provisioned Firefox/geckodriver and both file/HTTP variants where parameterized. Capacity cases require a freshly generated 30,000-Need/90,000-edge fixture; packaging requires the candidate wheel and offline wheelhouse. The procedure below specifies test-specific inputs. Executable selector: Invocation: Procedure and expected outcomes: Execute the following existing test procedure with its fixture helpers. Every assertion is a required observable outcome; expected error cases must assert the specified diagnostic/state. Links identify criterion portions exercised by this case, not a claim that this individual case alone verifies every linked requirement in full. Review the full case set and the release criterion assessment together. def test_invalid_model(change, path):
with pytest.raises(ValueError, match=path):
normalize(TYPES, LINKS, dict(MODEL, **change))
Evidence to retain: Per-case execution result and timestamp, candidate and test identities, environment, invocation and linked JUnit/log evidence. |
STV_TC_SW_039: Compact immutable detail assets
Level: Software component unit test. Executable selector: Preconditions/inputs: Three object identities; two identical rich fragments and one different fragment. Use a fresh output directory. Procedure and expected outcomes: Emit the actual graph/detail assets. Require exactly two detail files, full 64-character digest stems, identical manifest records for equal fragments, a different record for changed content, and registration of each full digest in the referenced asset. Inspect the graph by parsing its generated JSON registration payload. Evidence: Actual JUnit outcome, source identity and maintenance log; the system Windows-path case covers real browser/path/retry behavior. |
STV_TC_SW_041: Restored URLs obey the output-local policy
Level: Software component unit regression. Preconditions and inputs: Existing implementation environment; Node for frontend tests and provisioned Firefox/geckodriver for browser cases. Use a fresh isolated build; the test controls only harmless marker values and loopback resources. No external requests are needed. Executable selector: Invocation: Procedure and expected outcomes: Resolve local image paths under file and HTTP roots. Reject active schemes, remote, absolute, escaping and encoded-separator paths. Permit raster data images only for image resources. Evidence: Retain actual JUnit results, commands and source identities in PRSA-002 development fix verification. Design acceptance is recorded in Round 14: Owner acceptance for v1.0.0. |
STV_TC_SW_042: Restored CSS rejects unchecked resources
Level: Software component unit regression. Preconditions and inputs: Existing implementation environment; Node for frontend tests and provisioned Firefox/geckodriver for browser cases. Use a fresh isolated build; the test controls only harmless marker values and loopback resources. No external requests are needed. Executable selector: Invocation: Procedure and expected outcomes: Require canonical local CSS URLs to resolve; remote URLs become none. Imports, unquoted URLs and escaped syntax are rejected. Evidence: Retain actual JUnit results, commands and source identities in PRSA-002 development fix verification. Design acceptance is recorded in Round 14: Owner acceptance for v1.0.0. |
STV_TC_SW_044: Complete finite SVG bounds
Level/environment: Software component: pinned frontend dependencies and Node built-in test runner. Preconditions: Rebuilt local browser asset and isolated fixtures. Current development identity is retained separately from historical PoC evidence. Selector/invocation: Both Inputs/procedure: Nodes and outer routes with negative x/y, positive extents, and an empty scene. Compute the viewport and compare every point/corner against its padded bounds; verify equal CSS/viewBox origins retain world coordinates. Expected: All extents lie inside 24 px padding, origin cancellation is exact, and empty bounds have finite positive width/height. Browser endpoint alignment and reset behavior are independently covered by STV_TC_SY_059. |
STV_TC_SW_045: Natural ID ordering for fresh scenes
Level/environment: Software component: pinned frontend dependencies and Node built-in test runner. Preconditions: Rebuilt local browser asset and isolated fixtures. Current development identity is retained separately from historical PoC evidence. Selector: The natural numeric ID order case in Inputs/procedure: Supply shuffled REQ_20, REQ_10, REQ_3, REQ_2, REQ_1 in both seeded and synthetic project modes without authored visible edges. Compare left-to-right order, then expand REQ_2 to CHILD_A with committed context. Expected: Both modes produce 1,2,3,10,20 within the ordinary rank; synthetic root stays in its own band. Expansion preserves every original node position and does not insert-sort discovered nodes into occupied slots. |
STV_TC_SW_046: Validate classified placement configuration
Level/environment: Software component; pinned Python implementation venv. Procedure: Normalize renamed types with tag maps, owner maps, fixed levels and legacy role. Mutate unknown/empty levels, conflicting selectors, relation names, malformed tag/owner maps and fallback values; compare original inputs. Expected: Valid models normalize without mutation; invalid configuration fails with its field path. Owner maps only reference fixed/tag-resolved source levels. Run pytest for model/tests/test_model.py. |
STV_TC_SW_047: Resolve stable classification and fallback records
Level/environment: Graph component, pinned Python venv. Procedure: Classify tagged system/software cases, cross-level verifies links, multiple executions, renamed host types, conflicting/absent tags, no owners, multiple same/mixed owners and hidden owners. Resolve 30,000 case/execution records with 15,000 owner links. Compare reordered input records and untouched original data. Repeat without configured fallback. Expected: Fixed row per case/record, fallback with indication for ambiguity, strict Need-located failure without fallback, deterministic output and no hidden owner leakage. Classification uses the complete graph rather than visible paths. Run pytest for graph/tests/test_graph.py. |
STV_TC_SW_049: Ordered detail collection capacity and reuse
Environment: Node component tests under inspect/tests/collection.test.js. Procedure: Open distinct IDs with limits 1/3/10, reuse/focus old IDs, close middle/old entries, reopen them and clear one collection while another stays live. Expected: One live entry per ID, stable insertion age, exact oldest-first eviction only at capacity, no phantom eviction after manual close, independent collections and no entry creation for reuse. Invalid runtime limits reject. |
STV_TC_SW_050: Persistent limit configuration validation
Environment: Python model component tests plus Sphinx/browser integration. Procedure: Validate default/1/3/safe maximum; reject zero, negatives, bool, string, float, None and values above the safe integer range. Build a fixture with override 3 and verify published limit and live collection behavior. Expected: Clear setting-named errors for invalid configuration, exact validated integers and independent per-view enforcement without new runtime deps. |
Level/environment: Software component. Node state tests and renderer command harness with cyclic/shared adjacency, multiple seed IDs, cached project-page groups and deferred layout promises. Procedure: Apply reset after each command class; compare input/current/output identities; resolve old generations and reject a new layout. Enumerate empty/small/maximal entry and cap fixtures, plus independently allocated view state. Expected: Fresh sets/maps, retained seed identities, defined initial project state, revision increment, cleared page restoration and rooted bounded visibility. Inputs and unrelated view/card collections do not mutate. Only the current successful layout generation commits; rejected work is recoverable. |
Level/environment: Software component. Python MODEL/DIRECTIVE serialization tests plus real DOM typography harness using the installed host styles and actual browser computed values. Procedure: Try absent/default, 1.0, 0.8/0.6, bool/string/zero/negative/NaN/infinite input; compare graph digests. Measure parent/child px/em/rem typography in both presentations; reuse fragments and complete delayed content/fonts. Expected: Independent explicit new defaults, legacy fallback 1.0, setting-named build rejection, identity invalidation and exactly-once scaling. Relative hierarchy is retained within 0.5 CSS px; no host page or node summary side effects. |
Level/environment: Software component. EXPORT component tests with DOM fixtures plus browser computed-style harness; fake URL/anchor interfaces and controlled visual viewport/scroll/revisions. Procedure: Capture nested clips, negative scene origins, D3 transform, partially visible cards/text, pseudo-elements, namespaces and non-ASCII/markup-like titles. Mutate live presentation after capture. Exercise pointer cancel, keyboard, busy layout, zero-area crop, pending/failed fonts/resources, serializer exceptions, repeated downloads, timer and pagehide. Expected: Immutable coherent descriptor, exact crop/scroll transforms, parseable inert XML with escaped content and internal IDREFs; no live mutation or graph data. One in-flight job per view, safe bounded .svg filename, correct MIME, temporary nodes removed, and URL leases revoked on expiry/pagehide (immediately on error). No premature URL revocation or success claim about disk completion. Empty crops fail readably without download/page scrolling; pending/failed readiness never captures a later live revision implicitly. |
Level/environment: Software component. RENDER page-controller tests with actual Sphinx-Needs control markup, mixed metadata states, nested/copied tables, hidden rows and host click handlers. Procedure: Initialize twice, bulk-set both states twice, individually toggle, remove a table, add view/card copies before initialization and use pages without roots or without metadata; introduce unmatched/unsupported control encodings and mixed rows within one disclosure. Test initialization both before and after window load/jQuery readiness, wrapper keyboard forwarding and native icon clicks. Expected: Idempotent group/handlers, closest-table row ownership, explicit state setting through existing host handlers with synchronized ARIA/icons, no toggling of copied STV content and no hiding title/body. Disabled/no-group policy and explanatory failure match the interface contract. Exactly one native icon handler runs per activation; mixed rows become uniform, and individual clicks update row/icon state and ARIA without double toggles. |
Level/environment: Software component. Python DETAIL_BUILD/BUNDLE tests and EXPORT resource decoder; temporary output roots with raster/SVG/font/CSS/srcset dependencies, symlinks and an outside sentinel that must never be read. Runtime networking is blocked. Procedure: Resolve relative/encoded/non-ASCII paths and nested resources, test path escape, symlink escape, malformed MIME, active SVG, cyclic dependencies, absent local files, allowed raster data and remote URLs. Decode the generated classic-script record and select only captured currentSrc/font dependencies. Expected: Deterministic content identities and self-contained selected resources for valid fixtures, no outside read/runtime fetch or active execution. Missing required visible resources return typed failures; existing remote placeholders remain. JSON/script delimiters are safely escaped and no hidden Need data or unselected resource inventory enters the downloaded SVG. |
Environment: Node tests for STATE using a published-graph-shaped fixture and controlled storage. Procedure: Round-trip seed/project states, page memories and card order; remove objects/groups, change limits; inject malformed JSON/schema/coordinates, 200/201-node visibility and storage exceptions. Expected: Equivalent compatible state, atomic invalid-context/cap fallback, hidden objects absent, newest cards retained, independent keys/removal and explicit read/write/remove errors. Last completed save wins without live mutation. |