"""Analytical batch mechanics and authorization/failure boundary tests.""" import unittest from unittest.mock import patch from pathlib import Path import tempfile import numpy as np from scipy.sparse import csr_matrix from s3b_v04_math import fill_batches, reroute_once, SolverFailure, PressureEngine from s3b_v04_runtime import reserve_job, failure_classification, may_switch # Retain geometry, strict-region and actual subprocess I/O barrier checks. from test_s3b_graph import GraphTests from s2_recovery_supervisor import save from s3b_v04_runtime import read, OLD_CPU from run_s3b_v04_ten import run as run_ten class BatchTests(unittest.TestCase): def test_chain_both_solvers(self): for method in ['splu','gmres_ilu']: a,r,s=fill_batches(np.array([[0,1],[1,2]]),np.array([2.,3.]),np.array([2.,3.,5.]),0,method) np.testing.assert_allclose(a,[0,3,8],atol=2e-12) self.assertEqual(s['status'],'COMPLETE');self.assertEqual(r.sum(),0) self.assertEqual(s['initial_solves'],1) self.assertEqual(s['pressure_calls'],s['initial_solves']+s['scheduled_solves']+s['early_resolves']) def test_dead_end_keeps_half_filled_time_and_volume(self): # A has capacity .01 and dies at t=.02 while B is only .01 filled. # New pressure sends Q=1 to B; its capacity/time are not reset. for method in ['splu','gmres_ilu']: rows=[];states=[];pressures=[] a,r,s=fill_batches(np.array([[0,1],[0,2]]),np.ones(2),np.array([1.,.01,10.]),0,method, event_callback=rows.append,pressure_callback=pressures.append, state_callback=lambda row,r,a:states.append((dict(row),r.copy()))) np.testing.assert_allclose(a,[0,.02,10.01],atol=1e-10) self.assertEqual(s['early_resolves'],1) self.assertEqual(pressures[1]['reason'],'DEAD_END') self.assertTrue(rows[0]['early_resolve']) self.assertAlmostEqual(rows[0]['new_occupied_volume'],.02) self.assertAlmostEqual(states[1][1][2],9.99) self.assertGreater(rows[1]['graph_time'],rows[0]['graph_time']) self.assertAlmostEqual(rows[1]['batch_occupied_volume'],.005*11.01) self.assertAlmostEqual(sum(x['new_occupied_volume'] for x in rows),10.01) def test_single_reroute_simultaneous_sources_and_existing_rate(self): adj=csr_matrix(np.array([[0,7,1,2],[7,0,3,0],[1,3,0,0],[2,0,0,0]],float)) original=np.array([.3,.4,.1,.2]);full=np.array([True,True,False,False]) new,info=reroute_once(adj,original,full,np.array([0.,0.,3.,4.])) np.testing.assert_allclose(new,[0,0,.6,.4]);np.testing.assert_allclose(original,[.3,.4,.1,.2]) self.assertEqual(info['forwarded_nodes'],2);self.assertFalse(info['early_resolve']) def test_dead_end_prevents_partial_transfer(self): adj=csr_matrix(np.array([[0,0,1],[0,0,0],[1,0,0]],float)) rates=np.array([.4,.6,0.]);full=np.array([True,True,False]) new,info=reroute_once(adj,rates,full,np.array([0.,0.,2.])) self.assertIsNone(new);self.assertTrue(info['early_resolve']) np.testing.assert_array_equal(rates,[.4,.6,0.]) def test_diamond_ties_complete_without_final_solve(self): for method in ['splu','gmres_ilu']: a,r,s=fill_batches(np.array([[0,1],[0,2],[1,3],[2,3]]),np.ones(4),np.ones(4),0,method,batch_fraction=1.) np.testing.assert_allclose(a,[0,2,2,3]);self.assertEqual(s['pressure_calls'],1) self.assertEqual(s['events'],2);self.assertEqual(s['status'],'COMPLETE') def test_Q_g_scaling_and_permutation(self): e=np.array([[0,1],[0,2],[1,3],[2,3]]);g=np.array([1.,2.,3.,4.]);m=np.ones(4) a,_,_=fill_batches(e,g,m,0,'splu') b,_,_=fill_batches(e,g*13,m,0,'splu',Q=7) np.testing.assert_allclose(a,b*7,atol=2e-11) perm=np.array([2,3,1,0]);mm=np.empty_like(m);mm[perm]=m c,_,_=fill_batches(perm[e[::-1]],g[::-1],mm,int(perm[0]),'splu') np.testing.assert_allclose(a,c[perm],atol=2e-11) def test_zero_conductance_capacity_is_retained(self): for method in ['splu','gmres_ilu']: a,r,s=fill_batches(np.array([[0,1],[1,2]]),np.array([1.,0.]),np.array([1.,2.,4.]),0,method) self.assertEqual(s['status'],'BLOCKED');self.assertEqual(s['remaining_volume'],4) self.assertTrue(np.isnan(a[2]));self.assertEqual(r[2],4) def test_postcheck_rejects_bad_solver_exit_success(self): class BadFactor: def solve(self,b):return np.zeros_like(b) with patch('s3b_v04_math.splu',return_value=BadFactor()): with self.assertRaisesRegex(SolverFailure,'raw residual'): fill_batches(np.array([[0,1]]),np.ones(1),np.ones(2),0,'splu') with patch('s3b_v04_math.gmres',return_value=(np.zeros(1),0)): with self.assertRaises(SolverFailure): fill_batches(np.array([[0,1]]),np.ones(1),np.ones(2),0,'gmres_ilu') def test_shared_budget_preserves_postfit(self): self.assertTrue(reserve_job(61560.037823-1800)) self.assertFalse(reserve_job(61560.037823-1799.99)) def test_solver_failure_keeps_reason_and_reference_never_switches(self): guard=dict(status='STOPPED_OR_FAILED',monitor_errors=0,stop_reason=None) c=failure_classification(guard,dict(type='SolverFailure',message='raw residual=0.1')) self.assertEqual(c['category'],'NUMERICAL_FAILURE');self.assertIn('residual',c['reason']) self.assertTrue(may_switch('splu',c));self.assertFalse(may_switch('gmres_ilu',c)) self.assertFalse(may_switch('splu',c,gate='reference')) self.assertFalse(may_switch('splu',failure_classification(guard,dict(type='RoutingFailure',message='mass')))) for phase,expected in [('PRESSURE_FACTORIZE',True),('EXACT_MIDPOINTS',False),('SUBEVENT_ROUTING',False),('UNKNOWN',False)]: c=failure_classification(dict(guard,stop_reason='wall_limit'),progress={'stage':phase}) self.assertEqual(may_switch('splu',c),expected) self.assertFalse(may_switch('splu',failure_classification(guard))) def coordinator_fixture(self,failures): """Exercise actual dispatch/fallback/ledger without any scientific input.""" calls=[] def fake_supervise(command,dest,name,limits,**kw): method=command[-1];index=int(command[-2]);calls.append((method,index)) out=dest/'output';out.mkdir() fail=failures.get((method,index)) if fail: save(out/'failure.json',dict(type=fail,message=method+' original reason')) else:save(out/'result.json',dict(status='COMPLETE')) return dict(status='STOPPED_OR_FAILED' if fail else 'PASS',stop_reason=None, monitor_errors=0,cpu_seconds=2.) with tempfile.TemporaryDirectory() as temp: root=Path(temp);save(root/'contract.json',{});save(root/'code-freeze.json',{'git_commit':'synthetic'}) c=dict(coordinator_cpus=[0],worker_cpu=0,old_worker_CPU_s=OLD_CPU,new_synthetic_worker_CPU_s=3., candidate_order=['splu','gmres_ilu'],ten_parts=[{'case':str(i)} for i in range(10)], limits=dict(part_CPU_s=1800,part_wall_s=1800,part_RSS_bytes=4*2**30, ten_disk_bytes=5*2**30,total_worker_CPU_s=72000,postfit_reserve_CPU_s=7200)) with patch('run_s3b_v04_ten.contract',return_value=c),patch('run_s3b_v04_ten.supervise',side_effect=fake_supervise),patch('run_s3b_v04_ten.os.sched_setaffinity'),patch('run_s3b_v04_ten.signal.signal'): exitcode=run_ten(root) return exitcode,read(root/'complete.json'),calls def test_dispatch_restarts_whole_ten_only_once_and_charges_failures(self): code,r,calls=self.coordinator_fixture({('splu',2):'SolverFailure'}) self.assertEqual(code,0);self.assertEqual(r['selected_solver'],'gmres_ilu') self.assertEqual(calls,[('splu',i) for i in range(3)]+[('gmres_ilu',i) for i in range(10)]) self.assertEqual(r['new_worker_CPU_s'],29.) self.assertEqual(r['cumulative_worker_CPU_s'],OLD_CPU+29.) self.assertEqual(r['candidates'][0]['classification']['category'],'NUMERICAL_FAILURE') def test_two_numerical_failures_retained_without_third_candidate(self): code,r,calls=self.coordinator_fixture({('splu',0):'SolverFailure',('gmres_ilu',1):'SolverFailure'}) self.assertEqual(code,1);self.assertIsNone(r['selected_solver']) self.assertEqual(calls,[('splu',0),('gmres_ilu',0),('gmres_ilu',1)]) self.assertEqual([c['classification']['reason'] for c in r['candidates']], ['splu original reason','gmres_ilu original reason']) def test_nonsolver_failure_stops_dispatch_without_fallback(self): code,r,calls=self.coordinator_fixture({('splu',0):'RoutingFailure'}) self.assertEqual(code,1);self.assertEqual(calls,[('splu',0)]) if __name__=='__main__':unittest.main(verbosity=2)