722 lines
41 KiB
Python
722 lines
41 KiB
Python
"""Real FreeCAD/Open CASCADE integration checks (no mocked geometry).
|
|
|
|
Run inside portable FreeCAD Python, or import run(output_dir) from a GUI macro.
|
|
The report contains explicit pass/fail/skip flags and persistent evidence files.
|
|
"""
|
|
import json
|
|
import math
|
|
from pathlib import Path
|
|
import sys
|
|
import traceback
|
|
|
|
import FreeCAD as App
|
|
import Part
|
|
|
|
# FreeCAD itself may prepend workbench paths during import. Prefer repository
|
|
# source for validation when present; the packaged workbench is the fallback.
|
|
_SOURCE = Path(__file__).resolve().parents[1] / "src" / "QInventor"
|
|
if _SOURCE.is_dir():
|
|
sys.path.insert(0, str(_SOURCE))
|
|
import qi_model as model
|
|
|
|
|
|
def _assert(condition, message):
|
|
if not condition:
|
|
raise AssertionError(message)
|
|
|
|
|
|
def _near(actual, expected, relative=1e-8, absolute=1e-6):
|
|
_assert(math.isclose(float(actual), float(expected), rel_tol=relative, abs_tol=absolute),
|
|
"Expected %.12g, got %.12g" % (expected, actual))
|
|
|
|
|
|
def _sketches(body):
|
|
return [o for o in body.Group if o.isDerivedFrom("Sketcher::SketchObject")]
|
|
|
|
|
|
def _valid(body):
|
|
_assert(body.Shape.isValid(), "Invalid BRep")
|
|
_assert(len(body.Shape.Solids) == 1, "Expected a single solid")
|
|
_assert(body.Shape.Volume > 0, "Empty solid")
|
|
_assert(body.getStatusString() == "Valid", "Body status: " + body.getStatusString())
|
|
|
|
|
|
def _reject(fn):
|
|
try:
|
|
fn()
|
|
except (ValueError, RuntimeError):
|
|
return
|
|
raise AssertionError("Invalid input was accepted")
|
|
|
|
|
|
def _flat_exports_world_geometry_and_history(output_dir):
|
|
"""Analytical cold world geometry, immutable sources and atomic flat export."""
|
|
import hashlib
|
|
import io
|
|
import zipfile
|
|
import Mesh
|
|
|
|
def state(doc):
|
|
objects=[]
|
|
for obj in doc.Objects:
|
|
raw=bytes(obj.dumpContent())
|
|
if zipfile.is_zipfile(io.BytesIO(raw)):
|
|
with zipfile.ZipFile(io.BytesIO(raw)) as archive:
|
|
payload={n:hashlib.sha256(archive.read(n)).hexdigest() for n in sorted(archive.namelist())}
|
|
else:payload={'raw':hashlib.sha256(raw).hexdigest()}
|
|
objects.append({'name':obj.Name,'type':obj.TypeId,'payload':payload,
|
|
'expressions':list(obj.ExpressionEngine),'state':list(obj.State)})
|
|
return {'objects':objects,'undo':doc.UndoCount,'redo':doc.RedoCount,
|
|
'active_transaction':App.getActiveTransaction(),'active_doc':App.ActiveDocument.Name if App.ActiveDocument else None,
|
|
'documents':sorted(App.listDocuments()),'filename':doc.FileName}
|
|
|
|
def bounds(box):return [box.XMin,box.YMin,box.ZMin,box.XMax,box.YMax,box.ZMax]
|
|
|
|
def geometry(shape):
|
|
solids=list(shape.Solids); volume=sum(s.Volume for s in solids)
|
|
com=sum((s.CenterOfMass*s.Volume for s in solids),App.Vector())/volume if volume else App.Vector()
|
|
return {'type':shape.ShapeType,'valid':shape.isValid(),'solids':len(solids),'shells':len(shape.Shells),
|
|
'faces':len(shape.Faces),'volume_mm3':volume,'native_volume_mm3':shape.Volume,
|
|
'com_mm':list(com),'bounds_mm':bounds(shape.BoundBox)}
|
|
|
|
def comparison(expected,actual,tolerance=1e-6):
|
|
wanted,read=geometry(expected),geometry(actual)
|
|
missing=expected.cut(actual); excess=actual.cut(expected)
|
|
forward=0.0 if missing.isNull() else missing.Volume
|
|
reverse=0.0 if excess.isNull() else excess.Volume
|
|
return {'expected':wanted,'actual':read,'missing_volume_mm3':forward,'excess_volume_mm3':reverse,
|
|
'volume_delta_mm3':abs(read['volume_mm3']-wanted['volume_mm3']),
|
|
'com_distance_mm':math.dist(wanted['com_mm'],read['com_mm']),
|
|
'max_bound_delta_mm':max(abs(a-b) for a,b in zip(wanted['bounds_mm'],read['bounds_mm'])),
|
|
'matches':bool(read['valid'] and read['solids']==wanted['solids'] and forward<tolerance and reverse<tolerance
|
|
and abs(read['volume_mm3']-wanted['volume_mm3'])<tolerance
|
|
and math.dist(wanted['com_mm'],read['com_mm'])<tolerance
|
|
and max(abs(a-b) for a,b in zip(wanted['bounds_mm'],read['bounds_mm']))<tolerance)}
|
|
|
|
def box_shape(dimensions,base,degrees):
|
|
shape=Part.makeBox(*dimensions)
|
|
shape.Placement=App.Placement(App.Vector(*base),App.Rotation(App.Vector(0,0,1),degrees))
|
|
return shape
|
|
|
|
def body(doc,name,dimensions):
|
|
result=doc.addObject('PartDesign::Body',name)
|
|
box=result.newObject('PartDesign::AdditiveBox',name+'Box')
|
|
box.Length,box.Width,box.Height=dimensions
|
|
doc.recompute();assert result.Tip is box and result.Shape.isValid() and len(result.Shape.Solids)==1
|
|
return result
|
|
|
|
def fixture(kind,name):
|
|
doc=App.newDocument(name);doc.UndoMode=1
|
|
if kind=='placed_body':
|
|
selected=body(doc,'Body',(2,3,4))
|
|
parent=doc.addObject('App::Part','Definitions');parent.addObject(selected)
|
|
parent.Placement=App.Placement(App.Vector(50,60,70),App.Rotation(App.Vector(0,0,1),90))
|
|
selected.Placement=App.Placement(App.Vector(10,20,30),App.Rotation(App.Vector(0,0,1),90))
|
|
# Independent arithmetic: Rz90*(10,20,30)+(50,60,70)=(30,70,100), rotation180.
|
|
expected=box_shape((2,3,4),(30,70,100),180)
|
|
doc.recompute()
|
|
placements={'parent':[50,60,70,90],'body':[10,20,30,90],'independent_world':[30,70,100,180]}
|
|
elif kind in ('array','masked_array_virtual','masked_array_expanded','hidden_element','scaled_mirror_subassembly'):
|
|
definitions=doc.addObject('App::DocumentObjectGroup','Definitions')
|
|
source=doc.addObject('Part::Box','Definition');source.Length=2;source.Width=3;source.Height=4;definitions.addObject(source)
|
|
selected=doc.addObject('Assembly::AssemblyObject','Assembly')
|
|
selected.Placement=App.Placement(App.Vector(100,200,300),App.Rotation(App.Vector(0,0,1),90))
|
|
if kind in ('array','masked_array_virtual','masked_array_expanded','hidden_element'):
|
|
array=doc.addObject('App::Link','Array');array.setLink(source);array.LinkTransform=True;selected.addObject(array)
|
|
array.ShowElement=False;array.ElementCount=3
|
|
array.PlacementList=[App.Placement(App.Vector(x,0,0),App.Rotation()) for x in (0,10,20)]
|
|
array.ScaleList=[App.Vector(s,s,s) for s in (1,2,3)]
|
|
doc.recompute()
|
|
if kind in ('masked_array_expanded','hidden_element'):
|
|
array.ShowElement=True;doc.recompute()
|
|
expected=Part.makeCompound([box_shape((2*s,3*s,4*s),(100,200+10*i,300),90) for i,s in enumerate((1,2,3))])
|
|
placements={'root':[100,200,300,90],'array_local_x':[0,10,20],'array_scales':[1,2,3],
|
|
'independent_occurrences':3,'all_elements_visible':True}
|
|
if kind!='array':
|
|
doc.recompute();array.setElementVisible('1',False);doc.recompute()
|
|
assert [array.isElementVisible(str(i)) for i in range(3)]==[1,0,1]
|
|
if kind=='hidden_element':
|
|
assert len(array.ElementList)==3
|
|
selected=array.ElementList[1]
|
|
expected=box_shape((4,6,8),(100,210,300),90)
|
|
placements.update(explicitly_selected_hidden_element=selected.Name,independent_occurrences=1)
|
|
else:
|
|
expected=Part.makeCompound([box_shape((2,3,4),(100,200,300),90),box_shape((6,9,12),(100,220,300),90)])
|
|
placements.update(independent_occurrences=2)
|
|
placements.update(all_elements_visible=False,native_element_visibility=[1,0,1])
|
|
else:
|
|
sub=doc.addObject('Assembly::AssemblyObject','SubAssembly');definitions.addObject(sub)
|
|
for name_,x,angle in (('FirstChild',10,0),('SecondChild',30,90)):
|
|
child=doc.addObject('App::Link',name_);child.setLink(source);child.LinkTransform=True
|
|
child.LinkPlacement=App.Placement(App.Vector(x,0,0),App.Rotation(App.Vector(0,0,1),angle));sub.addObject(child)
|
|
for name_,x,scale in (('ScaledSub',50,2),('MirrorSub',200,-1)):
|
|
link=doc.addObject('App::Link',name_);link.setLink(sub);link.LinkTransform=True
|
|
link.LinkPlacement=App.Placement(App.Vector(x,0,0),App.Rotation());link.Scale=scale;selected.addObject(link)
|
|
expected=Part.makeCompound([box_shape((4,6,8),(100,270,300),90),box_shape((4,6,8),(100,310,300),180),
|
|
box_shape((3,2,4),(100,388,296),0),box_shape((2,3,4),(100,370,296),0)])
|
|
placements={'root':[100,200,300,90],'source_child_x':[10,30],'source_child_rotations_z':[0,90],
|
|
'linked_subassembly_local_x':[50,200],'linked_subassembly_scales':[2,-1],
|
|
'independent_occurrences':4,'independent_volume_mm3':432}
|
|
doc.recompute()
|
|
else:
|
|
definitions=doc.addObject('App::DocumentObjectGroup','Definitions')
|
|
first=body(doc,'FirstDefinition',(2,3,4));second=body(doc,'SecondDefinition',(5,6,7))
|
|
definitions.addObject(first);definitions.addObject(second)
|
|
selected=doc.addObject('Assembly::AssemblyObject','Assembly')
|
|
selected.Placement=App.Placement(App.Vector(100,200,300),App.Rotation(App.Vector(0,0,1),90))
|
|
for source,name_,base,rotation in ((first,'OccurrenceA',(10,20,30),90),(second,'OccurrenceB',(40,50,60),180)):
|
|
link=doc.addObject('App::Link',name_);link.setLink(source);link.LinkTransform=True
|
|
link.LinkPlacement=App.Placement(App.Vector(*base),App.Rotation(App.Vector(0,0,1),rotation))
|
|
selected.addObject(link)
|
|
# Exactly two independent occurrences; source definitions and container are not counted again.
|
|
expected=Part.makeCompound([box_shape((2,3,4),(80,210,330),180),box_shape((5,6,7),(50,240,360),270)])
|
|
doc.recompute()
|
|
placements={'root':[100,200,300,90],'A_local':[10,20,30,90],'B_local':[40,50,60,180],
|
|
'A_world':[80,210,330,180],'B_world':[50,240,360,270]}
|
|
marker=doc.addObject('App::FeaturePython','HistoryMarker');marker.addProperty('App::PropertyString','Text');marker.Text='before'
|
|
doc.recompute();doc.clearUndos();doc.openTransaction('Independent executable export Redo')
|
|
marker.Text='after';doc.commitTransaction();doc.undo();doc.recompute()
|
|
sentinel=App.newDocument(name+'Sentinel');App.setActiveDocument(sentinel.Name)
|
|
assert doc.UndoCount==0 and doc.RedoCount==1
|
|
return doc,selected,expected,marker,placements
|
|
|
|
def fault_control(model,out,suffix):
|
|
doc,selected,expected,marker,placements=fixture('placed_assembly','WriterFault'+suffix.replace('.',''))
|
|
destination=out/('protected-old'+suffix);old=b'owned previous complete exchange artifact';destination.write_bytes(old)
|
|
before=state(doc);files={p.name for p in out.iterdir()};injected='Owned post-native-writer failure'
|
|
native_part=model.Part
|
|
class CompoundWriter:
|
|
def __init__(self,shape):self.shape=shape
|
|
def exportBrep(self,path):self.shape.exportBrep(path);raise RuntimeError(injected)
|
|
def exportIges(self,path):self.shape.exportIges(path);raise RuntimeError(injected)
|
|
def __getattr__(self,name):return getattr(self.shape,name)
|
|
class PartProxy:
|
|
def makeCompound(self,shapes):return CompoundWriter(native_part.makeCompound(shapes))
|
|
def __getattr__(self,name):return getattr(native_part,name)
|
|
mesh_part=None;original_mesher=None
|
|
if suffix=='.stl':
|
|
import MeshPart
|
|
mesh_part=MeshPart;original_mesher=MeshPart.meshFromShape
|
|
class MeshWriter:
|
|
def __init__(self,mesh):self.mesh=mesh
|
|
def write(self,path):self.mesh.write(path);raise RuntimeError(injected)
|
|
MeshPart.meshFromShape=lambda **kwargs:MeshWriter(original_mesher(**kwargs))
|
|
else:model.Part=PartProxy()
|
|
try:
|
|
try:model.export_model(doc,destination,[selected])
|
|
except RuntimeError as exc:
|
|
assert str(exc)==injected,str(exc)
|
|
else:raise AssertionError('Injected post-writer failure was ignored')
|
|
finally:
|
|
model.Part=native_part
|
|
if mesh_part is not None:mesh_part.meshFromShape=original_mesher
|
|
after=state(doc)
|
|
assert before==after,'Post-writer error changed source payload/history/context'
|
|
assert destination.read_bytes()==old,'Post-writer error replaced previous destination'
|
|
assert {p.name for p in out.iterdir()}==files,'Post-writer error leaked or removed files'
|
|
doc.redo();doc.recompute();assert marker.Text=='after'
|
|
return {'source_before':before,'source_after':after,'original_exact_payload_history_active_doc':True,
|
|
'original_redo_executed':True,'old_destination_exact':True,'temporary_cleanup_exact':True,
|
|
'native_writer_completed_before_injected_failure':True,'before_first_world_query':True}
|
|
|
|
def empty_mask_control(model,out,suffix):
|
|
doc,selected,expected,marker,placements=fixture('array','EmptyMask'+suffix.replace('.',''))
|
|
for index in range(3):doc.Array.setElementVisible(str(index),False)
|
|
doc.recompute();before=state(doc)
|
|
destination=out/('protected-empty-mask'+suffix);old=b'owned previous nonempty model export';destination.write_bytes(old)
|
|
files={p.name for p in out.iterdir()}
|
|
try:model.export_model(doc,destination,[selected])
|
|
except ValueError as exc:error=str(exc)
|
|
else:raise AssertionError('All-hidden array was exported as successful empty geometry')
|
|
assert state(doc)==before,'Empty-mask rejection changed source payload/history/context'
|
|
assert destination.read_bytes()==old and {p.name for p in out.iterdir()}==files
|
|
doc.redo();doc.recompute();assert marker.Text=='after'
|
|
return {'original_exact_payload_history_active_doc':True,'original_redo_executed':True,
|
|
'old_destination_exact':True,'temporary_cleanup_exact':True,'empty_geometry_rejected':error,
|
|
'before_first_world_query':True}
|
|
|
|
output=Path(output_dir)/"flat-world-regression";output.mkdir(parents=True,exist_ok=True)
|
|
original_docs=set(App.listDocuments());active=App.ActiveDocument.Name if App.ActiveDocument else None
|
|
results=[]
|
|
def close_created():
|
|
for name in set(App.listDocuments())-original_docs:App.closeDocument(name)
|
|
if active and active in App.listDocuments():App.setActiveDocument(active)
|
|
elif not active:App.setActiveDocument("")
|
|
try:
|
|
for kind in ("placed_assembly","placed_body","array","scaled_mirror_subassembly","masked_array_virtual","masked_array_expanded","hidden_element"):
|
|
for selection in (("explicit",) if kind=="hidden_element" else ("default","explicit")):
|
|
for suffix in (".brep",".iges",".stl"):
|
|
name=kind+"-"+selection+suffix.replace(".","-")
|
|
try:
|
|
doc,selected,expected,marker,placements=fixture(kind,"FlatRegression"+name.replace("-",""))
|
|
before=state(doc)
|
|
assert state(doc)==before,"Read-only native payload snapshot is unstable"
|
|
destination=output/(name+suffix)
|
|
model.export_model(doc,destination,objects=None if selection=="default" else [selected])
|
|
assert state(doc)==before,"Export changed source payload/history/context: "+name
|
|
row={"case":name,"known_placements":placements,"exact_snapshot_before_first_world_query":True}
|
|
if suffix==".stl":
|
|
mesh=Mesh.Mesh();mesh.read(str(destination));wanted=geometry(expected)
|
|
for a,b in zip(wanted["bounds_mm"],bounds(mesh.BoundBox)):_near(a,b,absolute=1e-5)
|
|
_near(abs(mesh.Volume),wanted["volume_mm3"],absolute=1e-5)
|
|
assert mesh.isSolid() and mesh.CountFacets>=12*wanted["solids"]
|
|
row.update(stl_facets=mesh.CountFacets,volume_mm3=mesh.Volume,bounds_mm=bounds(mesh.BoundBox))
|
|
else:
|
|
actual=Part.read(str(destination));row["raw_readback"]=geometry(actual)
|
|
if suffix==".iges" and not actual.Solids:
|
|
actual.sewShape();shells=list(actual.Shells)
|
|
assert shells and all(shell.isClosed() for shell in shells),"IGES surfaces do not form closed shells"
|
|
actual=Part.makeCompound([Part.makeSolid(shell) for shell in shells])
|
|
row["iges_topology_readback"]="native sewShape of raw imported surfaces and closed-shell makeSolid"
|
|
row["comparison"]=comparison(expected,actual,1e-5)
|
|
assert row["comparison"]["matches"],row
|
|
assert state(doc)==before,"Readback changed source payload/history/context: "+name
|
|
doc.redo();doc.recompute();assert marker.Text=="after","Original Redo did not execute: "+name
|
|
row["original_redo_executed"]=True;results.append(row)
|
|
finally:close_created()
|
|
for suffix in (".brep",".iges",".stl"):
|
|
try:
|
|
fault=fault_control(model,output,suffix)
|
|
results.append({"case":"post-native-writer-fault"+suffix,
|
|
**{key:value for key,value in fault.items() if key not in ("source_before","source_after")}})
|
|
finally:close_created()
|
|
for suffix in (".brep",".iges",".stl"):
|
|
try:results.append({"case":"all-hidden-array-rejection"+suffix,**empty_mask_control(model,output,suffix)})
|
|
finally:close_created()
|
|
finally:close_created()
|
|
assert len(results)==45
|
|
return {"checks":len(results),"analytical_geometry_and_history":results}
|
|
|
|
|
|
def run(output_dir):
|
|
out = Path(output_dir).absolute()
|
|
out.mkdir(parents=True, exist_ok=True)
|
|
initial_docs = set(App.listDocuments())
|
|
active_name = App.ActiveDocument.Name if App.ActiveDocument else None
|
|
report = {"status": "running", "freecad_version": App.Version(), "gui": bool(App.GuiUp),
|
|
"source": model.__file__, "passed": 0, "failed": 0, "skipped": 0,
|
|
"checks": [], "artifacts": []}
|
|
|
|
def check(name, fn):
|
|
try:
|
|
detail = fn()
|
|
report["checks"].append({"name": name, "passed": True, "status": "passed", "detail": detail or {}})
|
|
report["passed"] += 1
|
|
except Exception as exc:
|
|
report["checks"].append({"name": name, "passed": False, "status": "failed",
|
|
"error": str(exc), "traceback": traceback.format_exc()})
|
|
report["failed"] += 1
|
|
# The report survives an unexpected later runtime/GUI failure.
|
|
(out / "kernel-report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
|
|
|
|
def artifact(path):
|
|
path = Path(path)
|
|
_assert(path.is_file() and path.stat().st_size > 0, "Missing artifact: " + str(path))
|
|
report["artifacts"].append(str(path))
|
|
return path
|
|
|
|
def box_volume_constraints():
|
|
doc = model.new_part("Проверка бруска")
|
|
body = model.create_box(80, 40, 20, doc)
|
|
_valid(body)
|
|
_near(body.Shape.Volume, 64000)
|
|
for actual, expected in zip(model.mass_properties(body)["dimensions_mm"], (80, 40, 20)):
|
|
_near(actual, expected)
|
|
sketch = _sketches(body)[0]
|
|
_assert(sketch.FullyConstrained and sketch.solve() == 0, "Rectangle not fully constrained")
|
|
_assert({c.Name for c in sketch.Constraints} >= {"Длина", "Ширина"}, "Missing localized named driving constraints")
|
|
_assert(body.Tip.TypeId == "PartDesign::Pad", "Box is not a native Pad")
|
|
return {"volume_mm3": body.Shape.Volume, "fully_constrained": True, "feature": body.Tip.TypeId}
|
|
|
|
def box_edit_undo_redo():
|
|
doc = model.new_part("Изменение размера")
|
|
body = model.create_box(20, 30, 10, doc)
|
|
model.set_dimensions(body, {"QILength": 25, "QIWidth": 40, "QIHeight": 12})
|
|
_near(body.Shape.Volume, 12000)
|
|
doc.undo()
|
|
doc.recompute()
|
|
body = doc.getObject(body.Name)
|
|
_near(body.Shape.Volume, 6000)
|
|
doc.redo()
|
|
doc.recompute()
|
|
_near(body.Shape.Volume, 12000)
|
|
# The native VarSet remains independently editable in the property editor.
|
|
body.QIParameters.QIHeight = 15
|
|
doc.recompute()
|
|
_near(body.Shape.Volume, 15000)
|
|
_valid(body)
|
|
return {"volume_mm3": body.Shape.Volume, "undo_redo": True, "native_parameters": body.QIParameters.TypeId}
|
|
|
|
def creation_undo_redo():
|
|
doc = model.new_part("История построения")
|
|
body = model.create_cylinder(8, 25, doc)
|
|
name = body.Name
|
|
doc.undo()
|
|
doc.recompute()
|
|
_assert(doc.getObject(name) is None, "Builder did not commit as a single undo operation")
|
|
doc.redo()
|
|
doc.recompute()
|
|
_near(doc.getObject(name).Shape.Volume, math.pi * 8 ** 2 * 25)
|
|
return {"single_creation_undo": True}
|
|
|
|
def cylinder_material():
|
|
doc = model.new_part("Материал цилиндра")
|
|
body = model.create_cylinder(12, 60, doc)
|
|
_valid(body)
|
|
_near(body.Shape.Volume, math.pi * 12 ** 2 * 60)
|
|
_assert(_sketches(body)[0].FullyConstrained, "Circle not fully constrained")
|
|
model.set_material(body, "Алюминий")
|
|
props = model.mass_properties(body)
|
|
_near(props["mass_kg"], body.Shape.Volume * 1e-9 * 2700)
|
|
model.set_dimension(body, "QIRadius", 15)
|
|
_near(body.Shape.Volume, math.pi * 15 ** 2 * 60)
|
|
return {"material": props["material"], "mass_kg": props["mass_kg"]}
|
|
|
|
def plate_parametric_holes():
|
|
doc = model.new_part("Проверка отверстий")
|
|
body = model.create_plate_with_holes(100, 50, 8, 10, 60, doc)
|
|
_near(body.Shape.Volume, (100 * 50 - 2 * math.pi * 5 ** 2) * 8)
|
|
_assert(all(s.FullyConstrained and s.solve() == 0 for s in _sketches(body)), "Plate sketches have degrees of freedom")
|
|
model.set_dimensions(body, {"QILength": 120, "QIWidth": 60, "QIThickness": 12,
|
|
"QIHoleDiameter": 12, "QIHoleSpacing": 90})
|
|
_near(body.Shape.Volume, (120 * 60 - 2 * math.pi * 6 ** 2) * 12)
|
|
holes = next(s for s in _sketches(body) if s.Name.startswith("HoleSketch"))
|
|
for circle, x in zip(holes.Geometry, (15, 105)):
|
|
_near(circle.Center.x, x)
|
|
_near(circle.Center.y, 30)
|
|
_near(circle.Radius, 6)
|
|
_near(holes.Placement.Base.z, 12)
|
|
_valid(body)
|
|
return {"volume_mm3": body.Shape.Volume, "fully_constrained": True, "holes": 2}
|
|
|
|
def atomic_dimensions_and_rejection():
|
|
doc = model.new_part("Атомарность размеров")
|
|
body = model.create_plate_with_holes(100, 50, 8, 10, 60, doc)
|
|
model.set_dimensions(body, {"QIHoleSpacing": 120, "QILength": 160})
|
|
_near(body.QILength.Value, 160)
|
|
_near(body.QIHoleSpacing.Value, 120)
|
|
before = body.Shape.Volume
|
|
_reject(lambda: model.set_dimensions(body, {"QILength": 80, "QIWidth": 20}))
|
|
_near(body.QILength.Value, 160)
|
|
_near(body.QIWidth.Value, 50)
|
|
_near(body.Shape.Volume, before)
|
|
_reject(lambda: model.set_dimensions(body, {"QIThickness": 12, "unknown": 1}))
|
|
_near(body.QIThickness.Value, 8)
|
|
return {"rejected_without_partial_changes": True}
|
|
|
|
def invalid_dimension_inputs():
|
|
doc = model.new_part("Проверка входных данных")
|
|
before = len(doc.Objects)
|
|
for invalid in (-1, 0, float("nan"), float("inf"), "abc", 1e20):
|
|
_reject(lambda v=invalid: model.create_box(v, 10, 10, doc))
|
|
_reject(lambda v=invalid: model.create_cylinder(v, 10, doc))
|
|
_reject(lambda: model.create_plate_with_holes(40, 20, 5, 15, 30, doc))
|
|
_reject(lambda: model.create_sketch_profile("rectangle", 20, 10, "BAD", doc))
|
|
_assert(len(doc.Objects) == before, "Invalid inputs modified document")
|
|
return {"invalid_cases": 14, "document_unchanged": True}
|
|
|
|
def free_sketch_dimensions():
|
|
doc = model.new_part("Именованные размеры эскиза")
|
|
sketch = model.create_sketch_profile("rectangle", 35, 20, doc=doc)
|
|
model.set_dimensions(sketch, {"Length": 50, "Width": 25})
|
|
_assert(sketch.FullyConstrained, "Dimensions caused underconstraint")
|
|
feature = model.pad(sketch, 10)
|
|
_near(feature.Shape.Volume, 12500)
|
|
circle = model.create_sketch_profile("circle", 7, 7, doc=doc)
|
|
model.set_dimension(circle, "Radius", 9)
|
|
feature2 = model.pad(circle, 15)
|
|
_near(feature2.Shape.Volume, math.pi * 9 ** 2 * 15)
|
|
return {"rectangle_driving_dimensions": [r["name"] for r in model.get_dimensions(sketch)], "circle_radius": 9}
|
|
|
|
def all_origin_planes():
|
|
doc = model.new_part("Плоскости эскиза")
|
|
expected_boxes = {"XY": (30, 20, 5), "XZ": (30, 5, 20), "YZ": (5, 30, 20)}
|
|
for plane, expected in expected_boxes.items():
|
|
sketch = model.create_sketch_profile("rectangle", 30, 20, plane, doc)
|
|
feature = model.pad(sketch, 5)
|
|
_near(feature.Shape.Volume, 3000)
|
|
box = feature.Shape.BoundBox
|
|
for actual, target in zip((box.XLength, box.YLength, box.ZLength), expected):
|
|
_near(actual, target)
|
|
return {"planes": list(expected_boxes)}
|
|
|
|
def pocket_and_rollback():
|
|
doc = model.new_part("Карман и откат")
|
|
body = model.create_box(50, 40, 10, doc)
|
|
sketch = model.create_sketch_profile("circle", 5, 5, doc=doc, body=body)
|
|
model.position_sketch_on_top(sketch, body)
|
|
placement = sketch.Placement
|
|
placement.Base.x, placement.Base.y = 25, 20
|
|
sketch.Placement = placement
|
|
cut = model.pocket(sketch, 10)
|
|
_near(cut.Shape.Volume, 20000 - math.pi * 25 * 10)
|
|
bad = model.create_sketch_profile("circle", 2, 2, doc=doc, body=body)
|
|
model.position_sketch_on_top(bad, body)
|
|
placement = bad.Placement
|
|
placement.Base = App.Vector(500, 500, 10)
|
|
bad.Placement = placement
|
|
before_names = {o.Name for o in doc.Objects}
|
|
_reject(lambda: model.pocket(bad, 10))
|
|
_assert({o.Name for o in doc.Objects} == before_names, "Failed feature transaction did not roll back")
|
|
_near(cut.Shape.Volume, 20000 - math.pi * 25 * 10)
|
|
return {"real_subtractive_volume_mm3": cut.Shape.Volume, "failed_pocket_rolled_back": True}
|
|
|
|
def save_and_reopen():
|
|
doc = model.make_demo("bracket")
|
|
name = doc.Name
|
|
body = doc.getObject("Body")
|
|
volume = body.Shape.Volume
|
|
path = artifact(model.save_project(doc, out / "parametric-bracket.FCStd"))
|
|
App.closeDocument(name)
|
|
reopened = App.openDocument(str(path))
|
|
body = reopened.getObject("Body")
|
|
_near(body.Shape.Volume, volume)
|
|
_assert(all(s.FullyConstrained for s in _sketches(body)), "Saved constraints lost")
|
|
model.set_dimensions(body, {"QIWallHeight": 55, "QIThickness": 10})
|
|
_near(body.Shape.Volume, (100 * 50 - 2 * math.pi * 5 ** 2) * 10 + 50 * 55 * 10)
|
|
_valid(body)
|
|
return {"native_project": str(path), "editable_after_reopen": True}
|
|
|
|
def step_round_trip():
|
|
doc = model.make_demo("bracket")
|
|
body = doc.getObject("Body")
|
|
path = artifact(model.export_model(doc, out / "bracket.step"))
|
|
shape = Part.read(str(path))
|
|
_assert(shape.isValid() and len(shape.Solids) == 1, "STEP did not round-trip a solid")
|
|
_near(shape.Volume, body.Shape.Volume, relative=1e-6)
|
|
return {"path": str(path), "imported_volume_mm3": shape.Volume, "valid": True}
|
|
|
|
def solid_export_formats():
|
|
doc = model.new_part("Экспорт форматов")
|
|
body = model.create_box(25, 20, 10, doc)
|
|
paths = [artifact(model.export_model(doc, out / ("solid." + ext))) for ext in ("iges", "brep", "stl")]
|
|
shape = Part.read(str(out / "solid.brep"))
|
|
_near(shape.Volume, body.Shape.Volume)
|
|
import Mesh
|
|
mesh = Mesh.Mesh(str(out / "solid.stl"))
|
|
_assert(mesh.CountFacets >= 12, "STL has insufficient facets")
|
|
return {"formats": [p.suffix for p in paths], "stl_facets": mesh.CountFacets}
|
|
|
|
def export_rejects_non_solids():
|
|
doc = model.new_part("Проверка геометрии экспорта")
|
|
body = model.create_box(20, 10, 5, doc)
|
|
sketch = _sketches(body)[0]
|
|
empty = doc.addObject("Part::Feature", "Empty")
|
|
wire = doc.addObject("Part::Feature", "Wire")
|
|
wire.Shape = Part.makePolygon([App.Vector(0, 0, 0), App.Vector(10, 0, 0)])
|
|
mixed = doc.addObject("Part::Feature", "Mixed")
|
|
mixed.Shape = Part.makeCompound([body.Shape, wire.Shape])
|
|
doc.recompute()
|
|
rejected = []
|
|
for obj in (sketch, empty, wire, mixed):
|
|
for ext in ("step", "iges", "brep", "stl"):
|
|
path = out / ("rejected-" + obj.Name + "." + ext)
|
|
try:
|
|
model.export_model(doc, path, [obj])
|
|
except ValueError as exc:
|
|
_assert("твердого тела" in str(exc), "Missing Russian solid-geometry error")
|
|
else:
|
|
raise AssertionError("Non-solid selection was exported: " + obj.Name)
|
|
_assert(not path.exists(), "Rejected export created a misleading file")
|
|
rejected.append(obj.Name + "." + ext)
|
|
existing = out / "rejected-existing.step"
|
|
existing.write_bytes(b"existing project exchange file")
|
|
before = existing.read_bytes()
|
|
_reject(lambda: model.export_model(doc, existing, [sketch]))
|
|
_assert(existing.read_bytes() == before, "Rejected export overwrote an existing file")
|
|
return {"rejected_selections": rejected, "existing_file_preserved": True}
|
|
|
|
def export_rejects_cached_failed_feature():
|
|
doc = model.new_part("Ошибка перестроения перед экспортом")
|
|
body = model.create_box(20, 10, 5, doc)
|
|
pad = body.Tip
|
|
link = doc.addObject("App::Link", "ExportLink")
|
|
link.setLink(body)
|
|
doc.recompute()
|
|
volume = body.Shape.Volume
|
|
pad.setExpression("Length", None)
|
|
pad.Length = 0
|
|
doc.recompute()
|
|
_assert("Invalid" in pad.State, "Fixture did not trigger a real native error")
|
|
_assert(pad.getStatusString() != "Valid", "Fixture has no native error status")
|
|
_assert(pad.Shape.isValid() and body.Shape.isValid(), "Fixture did not retain the old valid solid")
|
|
_near(body.Shape.Volume, volume)
|
|
native_status = pad.getStatusString()
|
|
rejected = 0
|
|
for selection in (None, [body], [pad], [link]):
|
|
for ext in ("step", "iges", "brep", "stl"):
|
|
path = out / ("failed-rebuild-%d.%s" % (rejected, ext))
|
|
try:
|
|
model.export_model(doc, path, selection)
|
|
except ValueError as exc:
|
|
_assert("ошибку перестроения" in str(exc), "Missing Russian rebuild error")
|
|
else:
|
|
raise AssertionError("A stale solid was exported after a native rebuild failure")
|
|
_assert(not path.exists(), "Failed rebuild created a misleading export")
|
|
rejected += 1
|
|
# An unrelated erroneous object should not prevent exporting an explicitly
|
|
# chosen independent, valid Body or its native feature.
|
|
good = model.create_box(7, 6, 5, doc)
|
|
accepted = artifact(model.export_model(doc, out / "independent-good-body.step", [good]))
|
|
_near(Part.read(str(accepted)).Volume, 210)
|
|
pad.Length = 8
|
|
doc.recompute()
|
|
_assert("Invalid" not in pad.State, "Native Pad did not recover")
|
|
recovered = artifact(model.export_model(doc, out / "recovered-body.step", [body]))
|
|
_near(Part.read(str(recovered)).Volume, 1600)
|
|
return {"native_error": native_status, "cached_volume_mm3": volume,
|
|
"rejected_exports": rejected, "independent_and_recovered_exports": True}
|
|
|
|
def assembly_solver_links_bom():
|
|
doc = model.create_assembly_demo()
|
|
assembly = doc.getObject("Assembly")
|
|
_assert(assembly.TypeId == "Assembly::AssemblyObject" and assembly.Type == "Assembly", "Non-native assembly")
|
|
links = [o for o in assembly.Group if o.isDerivedFrom("App::Link")]
|
|
_assert(len(links) == 3, "Assembly requires three linked components")
|
|
_assert(assembly.isPartGrounded(links[0]), "Base not grounded")
|
|
types = {o.JointType for o in doc.Objects if hasattr(o, "JointType")}
|
|
_assert(types == {"Fixed", "Revolute"}, "Missing native mates")
|
|
fixed = links[1]
|
|
moved = fixed.LinkPlacement
|
|
moved.Base = App.Vector(45, 35, 5)
|
|
fixed.LinkPlacement = moved
|
|
status = assembly.solve(False)
|
|
doc.recompute()
|
|
_assert(status == 0, "Assembly solver failed")
|
|
_near(fixed.LinkPlacement.Base.x, 20)
|
|
_near(fixed.LinkPlacement.Base.y, 30)
|
|
_near(fixed.LinkPlacement.Base.z, 0)
|
|
rows = model.bom_rows(doc)
|
|
_assert(sorted(r["quantity"] for r in rows) == [1, 2], "BOM quantity grouping incorrect")
|
|
csv = artifact(model.export_bom(doc, out / "assembly-bom.csv"))
|
|
_assert("QI-002" in csv.read_text(encoding="utf-8-sig"), "BOM CSV missing part")
|
|
pin = links[1].getLinkedObject()
|
|
model.set_dimensions(pin, {"QIRadius": 6, "QIHeight": 40})
|
|
doc.recompute()
|
|
for link in links[1:]:
|
|
_near(link.Shape.Volume, math.pi * 6 ** 2 * 40)
|
|
artifact(model.save_project(doc, out / "native-assembly.FCStd"))
|
|
return {"solver_status": status, "joint_types": sorted(types), "components": 3, "bom_rows": rows}
|
|
|
|
def assembly_reopen_step():
|
|
path = out / "native-assembly.FCStd"
|
|
_assert(path.is_file(), "Assembly artifact absent")
|
|
reopened = App.openDocument(str(path))
|
|
assembly = reopened.getObject("Assembly")
|
|
_assert(assembly.solve(False) == 0, "Reopened joints failed to solve")
|
|
_assert(sorted(r["quantity"] for r in model.bom_rows(reopened)) == [1, 2], "BOM lost after reopen")
|
|
step = artifact(model.export_model(reopened, out / "assembly.step"))
|
|
shape = Part.read(str(step))
|
|
_assert(len(shape.Solids) == 3 and shape.isValid(), "STEP assembly lost components")
|
|
return {"reopened_joints": True, "step_solids": len(shape.Solids)}
|
|
|
|
def drawing_associativity():
|
|
doc = model.new_part("Чертеж детали")
|
|
body = model.create_box(80, 40, 20, doc)
|
|
page = model.create_drawing(doc)
|
|
model.prepare_drawing(page)
|
|
_assert(page.TypeId == "TechDraw::DrawPage" and len(page.Views) == 3, "Drawing projections absent")
|
|
_assert(all(v.Source == [body] for v in page.Views), "Drawing source links missing")
|
|
_assert(all(len(v.getVisibleEdges()) >= 4 for v in page.Views), "Native projections contain no visible edges")
|
|
_assert(page.Template.Width.Value > 200 and page.Template.Height.Value > 200, "A4 template dimensions invalid")
|
|
_assert([(v.X.Value, v.Y.Value) for v in page.Views] == [(80.0, 135.0), (80.0, 80.0), (205.0, 123.0)],
|
|
"Drawing insertion reset projection layout")
|
|
_near(page.Scale, 1)
|
|
_assert(page.Template.EditableTexts.get("Scale") == "1:1", "Unexpected standard scale label")
|
|
# Export immediately after rapid source edits. Waiting/preparing here
|
|
# would hide a DXF exporter that serializes the previous cached view.
|
|
model.set_dimensions(body, {"QILength": 90, "QIHeight": 35})
|
|
model.set_dimensions(body, {"QILength": 100, "QIHeight": 50})
|
|
dxf = artifact(model.export_drawing(page, out / "associative-drawing.dxf"))
|
|
dxf_lines = dxf.read_text(encoding="utf-8", errors="replace").splitlines()
|
|
section, record, front_lines = "", [], []
|
|
for raw_code, raw_value in zip(dxf_lines[::2], dxf_lines[1::2]):
|
|
code, value = int(raw_code), raw_value.strip()
|
|
if code == 0:
|
|
if (section == "ENTITIES" and record and record[0] == (0, "LINE")
|
|
and (8, "FrontView") in record):
|
|
front_lines.append(record)
|
|
record = [(code, value)]
|
|
if value == "ENDSEC":
|
|
section = ""
|
|
elif code == 2 and record and record[0] == (0, "SECTION"):
|
|
section = value
|
|
else:
|
|
record.append((code, value))
|
|
_assert(len(front_lines) >= 4, "DXF contains no native front projection")
|
|
x_coordinates = [float(value) for record in front_lines for code, value in record if code in (10, 11)]
|
|
y_coordinates = [float(value) for record in front_lines for code, value in record if code in (20, 21)]
|
|
dxf_width = max(x_coordinates) - min(x_coordinates)
|
|
dxf_height = max(y_coordinates) - min(y_coordinates)
|
|
_near(dxf_width, 100 * page.Scale)
|
|
_near(dxf_height, 50 * page.Scale)
|
|
_assert(all(v.getStatusString() == "Valid" for v in page.Views), "Views failed after model edit")
|
|
artifact(model.save_project(doc, out / "associative-drawing.FCStd"))
|
|
if App.GuiUp:
|
|
exported_svg = artifact(model.export_drawing(page, out / "associative-drawing.svg"))
|
|
_assert(model._svg_has_geometry(exported_svg), "Exported SVG has no projected model geometry")
|
|
artifact(model.export_drawing(page, out / "associative-drawing.pdf"))
|
|
return {"views": 3, "model_change_recomputed": True, "gui_exports": bool(App.GuiUp),
|
|
"direct_dxf_after_rapid_edits": True, "dxf_front_width_mm": dxf_width,
|
|
"dxf_front_height_mm": dxf_height}
|
|
|
|
def complete_examples():
|
|
volumes = {}
|
|
for kind in ("bracket", "plate", "shaft", "pulley"):
|
|
doc = model.make_demo(kind)
|
|
body = doc.getObject("Body")
|
|
_valid(body)
|
|
_assert(all(s.FullyConstrained for s in _sketches(body)), "Example sketch not fully constrained")
|
|
volumes[kind] = body.Shape.Volume
|
|
return {"volumes_mm3": volumes}
|
|
|
|
tests = [
|
|
("box_volume_constraints", box_volume_constraints),
|
|
("box_edit_undo_redo", box_edit_undo_redo),
|
|
("creation_undo_redo", creation_undo_redo),
|
|
("cylinder_material", cylinder_material),
|
|
("plate_parametric_holes", plate_parametric_holes),
|
|
("atomic_dimensions_and_rejection", atomic_dimensions_and_rejection),
|
|
("invalid_dimension_inputs", invalid_dimension_inputs),
|
|
("free_sketch_dimensions", free_sketch_dimensions),
|
|
("all_origin_planes", all_origin_planes),
|
|
("pocket_and_rollback", pocket_and_rollback),
|
|
("save_and_reopen", save_and_reopen),
|
|
("step_round_trip", step_round_trip),
|
|
("solid_export_formats", solid_export_formats),
|
|
("flat_exports_world_geometry_and_history", lambda: _flat_exports_world_geometry_and_history(out)),
|
|
("export_rejects_non_solids", export_rejects_non_solids),
|
|
("export_rejects_cached_failed_feature", export_rejects_cached_failed_feature),
|
|
("assembly_solver_links_bom", assembly_solver_links_bom),
|
|
("assembly_reopen_step", assembly_reopen_step),
|
|
("drawing_associativity", drawing_associativity),
|
|
("complete_examples", complete_examples),
|
|
]
|
|
try:
|
|
for name, fn in tests:
|
|
check(name, fn)
|
|
finally:
|
|
for name in set(App.listDocuments()) - initial_docs:
|
|
App.closeDocument(name)
|
|
if active_name in App.listDocuments():
|
|
App.setActiveDocument(active_name)
|
|
if not App.GuiUp:
|
|
report["skipped"] += 1
|
|
report["checks"].append({"name": "drawing_pdf_svg_gui", "passed": None, "status": "skipped",
|
|
"reason": "Headless run: full page PDF/SVG export needs GUI; native page/DXF verified."})
|
|
report["status"] = "passed" if report["failed"] == 0 else "failed"
|
|
report["success"] = report["failed"] == 0
|
|
(out / "kernel-report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
|
|
return report
|
|
|
|
|
|
if __name__ == "__main__":
|
|
output = sys.argv[1] if len(sys.argv) > 1 else str(Path(__file__).resolve().parents[1] / "artifacts" / "kernel")
|
|
result = run(output)
|
|
print(json.dumps({k: result[k] for k in ("status", "passed", "failed", "skipped")}, ensure_ascii=False))
|
|
if result["failed"]:
|
|
for item in result["checks"]:
|
|
if item["status"] == "failed":
|
|
print(item["name"] + ": " + item["error"])
|
|
raise SystemExit(0 if result["success"] else 1)
|