From 18cb767a951cad8842a8d9393033c06d7cb8f2d0 Mon Sep 17 00:00:00 2001 From: Dion Moult Date: Tue, 31 May 2022 22:27:16 +1000 Subject: [PATCH] More IDS test structuring and add support for checking logical unknown --- src/ifcopenshell-python/ifcopenshell/ids.py | 27 +- .../test/ids_doc_generator.py | 60 ++-- src/ifcopenshell-python/test/test_ids.py | 327 +++++++++--------- 3 files changed, 233 insertions(+), 181 deletions(-) diff --git a/src/ifcopenshell-python/ifcopenshell/ids.py b/src/ifcopenshell-python/ifcopenshell/ids.py index fa045ff683..3a3312a8bc 100644 --- a/src/ifcopenshell-python/ifcopenshell/ids.py +++ b/src/ifcopenshell-python/ifcopenshell/ids.py @@ -618,6 +618,7 @@ class attribute(facet): if isinstance(self.name, str): type_value = getattr(element_type, self.name, None) if element_type else None occurrence_value = getattr(inst, self.name, None) + names = [self.name] values = [occurrence_value if occurrence_value is not None else type_value] else: if element_type: @@ -625,9 +626,31 @@ class attribute(facet): info.update({k: v for k, v in inst.get_info().items() if v is not None}) else: info = inst.get_info() - values = [v for k, v in info.items() if k == self.name] + names = [] + values = [] + for k, v in info.items(): + if k == self.name: + names.append(k) + values.append(v) + + is_pass = bool(values) + + if is_pass: + for i, value in enumerate(values): + if value is None: + is_pass = False + elif value == "": + is_pass = False + elif value == tuple(): + is_pass = False + elif ( + inst.attribute_type(inst.wrapped_data.get_argument_index(names[i])) == "LOGICAL" + and value == "UNKNOWN" + ): + is_pass = False + if not is_pass: + break - is_pass = bool(values) and all([v is not None and v != "" for v in values]) if is_pass and self.value: is_pass = all([v == self.value for v in values]) diff --git a/src/ifcopenshell-python/test/ids_doc_generator.py b/src/ifcopenshell-python/test/ids_doc_generator.py index cb843d69d2..d9142fbf09 100644 --- a/src/ifcopenshell-python/test/ids_doc_generator.py +++ b/src/ifcopenshell-python/test/ids_doc_generator.py @@ -28,14 +28,17 @@ from ifcopenshell import ids, template, validate outdir = "build" -class spec_generator: - cases = [] + +class DocGenerator: + def __init__(self): + self.facet = None + self.testcases = {} def __call__(self, name, *, facet, inst, expected): if not name: return - fail_or_pass = "pass" if expected is True else "fail" + result = "pass" if expected is True else "fail" # Create an IFC file with the instance in `inst` passed to us # based on an IFC file template with project and units. @@ -61,11 +64,11 @@ class spec_generator: else: raise Exception("About to emit invalid example data") - ifc_text = "\n".join( - map(str, {inst: None for inst in itertools.chain.from_iterable(map(f.traverse, instances))}.keys()) - ) + ifc_lines = list(map(str, {i: None for i in itertools.chain.from_iterable(map(f.traverse, instances))}.keys())) + ifc_id = ifc_lines[0].split("=")[0] + ifc_text = "\n".join(ifc_lines) - basename = f"{fail_or_pass}-" + re.sub("[^0-9a-zA-Z]", "_", name.lower()) + basename = f"{result}-" + re.sub("[^0-9a-zA-Z]", "_", name.lower()) # Write IFC to disk f.write(os.path.join(outdir, f"{basename}.ifc")) @@ -92,30 +95,39 @@ class spec_generator: if l.strip() ).replace("\t", " ") - self.cases.append({ - "name": name, "ids": xml_text, "ifc": ifc_text, "basename": basename, "result": fail_or_pass - }) + self.testcases.setdefault(self.facet, []).append( + {"name": name, "ids": xml_text, "ifc": ifc_text, "basename": basename, "result": result, "id": ifc_id} + ) assert bool(facet(inst)) is expected + def set_facet(self, facet): + self.facet = facet -test_ids.case = spec_generator() -suite = unittest.TestLoader().discover('.', pattern='test_ids.py') +test_ids.run = DocGenerator() +test_ids.set_facet = test_ids.run.set_facet + +suite = unittest.TestLoader().discover(".", pattern="test_ids.py") result = unittest.TextTestRunner(verbosity=2).run(suite) -with open(os.path.join(outdir, "spec.md"), "w") as f: - for c in test_ids.case.cases: +for facet, testcases in test_ids.run.testcases.items(): + with open(os.path.join(outdir, f"testcases-{facet}.md"), "w") as f: write = functools.partial(print, file=f) - write(f"## [{c['result'].upper()}] {c['name']}") + write(f"# {facet.capitalize()} testcases") write() - write("~~~xml") - write(c['ids']) - write("~~~") - write() - write("~~~lua") - write(c['ifc']) - write("~~~") - write() - write(f"[Sample IDS]({c['basename']}.ids) - [Sample IFC]({c['basename']}.ifc)") + write("These testcases are designed to help describe behaviour in edge cases and ambiguities. All valid IDS implementations must demonstrate identical behaviour to these test cases.") write() + for testcase in testcases: + write(f"## [{testcase['result'].upper()}] {testcase['name']}") + write() + write("~~~xml") + write(testcase["ids"]) + write("~~~") + write() + write("~~~lua") + write(testcase["ifc"]) + write("~~~") + write() + write(f"[Sample IDS]({testcase['basename']}.ids) - [Sample IFC: {testcase['id']}]({testcase['basename']}.ifc)") + write() diff --git a/src/ifcopenshell-python/test/test_ids.py b/src/ifcopenshell-python/test/test_ids.py index 1eae3388e8..a8739700e9 100644 --- a/src/ifcopenshell-python/test/test_ids.py +++ b/src/ifcopenshell-python/test/test_ids.py @@ -41,7 +41,10 @@ ifc_file = ifcopenshell.open(IFC_URL) os.remove(os.path.join(tempfile.gettempdir(), "test.ifc")) -def case(name, *, facet, inst, expected): +def set_facet(facet): + pass + +def run(name, *, facet, inst, expected): assert bool(facet(inst)) is expected @@ -257,20 +260,22 @@ class TestIdsAuthoring(unittest.TestCase): } def test_filtering_using_an_entity_facet(self): + set_facet("entity") + ifc = ifcopenshell.file() facet = ids.entity.create(name="IFCRABBIT") - case("Invalid entities always fail", facet=facet, inst=ifc.createIfcWall(), expected=False) + run("Invalid entities always fail", facet=facet, inst=ifc.createIfcWall(), expected=False) facet = ids.entity.create(name="IFCWALL") - case("A matching entity should pass", facet=facet, inst=ifc.createIfcWall(), expected=True) - case( + run("A matching entity should pass", facet=facet, inst=ifc.createIfcWall(), expected=True) + run( "An matching entity should pass regardless of predefined type", facet=facet, inst=ifc.createIfcWall(PredefinedType="SOLIDWALL"), expected=True, ) - case( + run( "An entity not matching the specified class should fail", facet=facet, inst=ifc.createIfcSlab(), @@ -278,7 +283,7 @@ class TestIdsAuthoring(unittest.TestCase): ) # TODO: Some votes to prefer inheritance (For: Moult, Evandro, Artur) # Possible argument: CAD tools don't understand IFC - case( + run( "Subclasses are not considered as matching", facet=facet, inst=ifc.createIfcWallStandardCase(), @@ -287,7 +292,7 @@ class TestIdsAuthoring(unittest.TestCase): # TODO But in that case why are the enumerations for things like partOf using the IFC capitalisation? facet = ids.entity.create(name="IfcWall") - case( + run( "Entities must be specified as uppercase strings", facet=facet, inst=ifc.createIfcWall(), @@ -295,19 +300,19 @@ class TestIdsAuthoring(unittest.TestCase): ) facet = ids.entity.create(name="IFCWALL", predefinedType="SOLIDWALL") - case( + run( "A matching predefined type should pass", facet=facet, inst=ifc.createIfcWall(PredefinedType="SOLIDWALL"), expected=True, ) - case( + run( "A null predefined type should always fail a specified predefined types", facet=facet, inst=ifc.createIfcWall(), expected=False, ) - case( + run( "An entity not matching a specified predefined type will fail", facet=facet, inst=ifc.createIfcWall(PredefinedType="PARTITIONING"), @@ -315,7 +320,7 @@ class TestIdsAuthoring(unittest.TestCase): ) facet = ids.entity.create(name="IFCWALL", predefinedType="solidwall") - case( + run( "A predefined type from an enumeration must be uppercase", facet=facet, inst=ifc.createIfcWall(PredefinedType="SOLIDWALL"), @@ -323,7 +328,7 @@ class TestIdsAuthoring(unittest.TestCase): ) facet = ids.entity.create(name="IFCWALL", predefinedType="WALDO") - case( + run( "A predefined type may specify a user-defined object type", facet=facet, inst=ifc.createIfcWall(PredefinedType="USERDEFINED", ObjectType="WALDO"), @@ -331,7 +336,7 @@ class TestIdsAuthoring(unittest.TestCase): ) facet = ids.entity.create(name="IFCWALL", predefinedType="WALDO") - case( + run( "User-defined types are checked case sensitively", facet=facet, inst=ifc.createIfcWall(PredefinedType="USERDEFINED", ObjectType="waldo"), @@ -339,7 +344,7 @@ class TestIdsAuthoring(unittest.TestCase): ) facet = ids.entity.create(name="IFCWALLTYPE", predefinedType="WALDO") - case( + run( "A predefined type may specify a user-defined element type", facet=facet, inst=ifc.createIfcWallType(PredefinedType="USERDEFINED", ElementType="WALDO"), @@ -347,7 +352,7 @@ class TestIdsAuthoring(unittest.TestCase): ) facet = ids.entity.create(name="IFCTASKTYPE", predefinedType="TASKY") - case( + run( "A predefined type may specify a user-defined process type", facet=facet, inst=ifc.createIfcTaskType(PredefinedType="USERDEFINED", ProcessType="TASKY"), @@ -355,7 +360,7 @@ class TestIdsAuthoring(unittest.TestCase): ) facet = ids.entity.create(name="IFCWALL", predefinedType="USERDEFINED") - case( + run( "A predefined type must always specify a meaningful type, not USERDEFINED itself", facet=facet, inst=ifc.createIfcWall(PredefinedType="USERDEFINED", ObjectType="WALDO"), @@ -366,7 +371,7 @@ class TestIdsAuthoring(unittest.TestCase): wall_type = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWallType", predefined_type="X") ifcopenshell.api.run("type.assign_type", ifc, related_object=wall, relating_type=wall_type) facet = ids.entity.create(name="IFCWALL", predefinedType="X") - case("Inherited predefined types should pass", facet=facet, inst=wall, expected=True) + run("Inherited predefined types should pass", facet=facet, inst=wall, expected=True) wall = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall", predefined_type="X") wall_type = ifcopenshell.api.run( @@ -374,30 +379,30 @@ class TestIdsAuthoring(unittest.TestCase): ) ifcopenshell.api.run("type.assign_type", ifc, related_object=wall, relating_type=wall_type) facet = ids.entity.create(name="IFCWALL", predefinedType="X") - case("Overridden predefined types should pass", facet=facet, inst=wall, expected=True) + run("Overridden predefined types should pass", facet=facet, inst=wall, expected=True) # Restrictions are allowed when matching the IFC class restriction = ids.restriction.create(options=["IFCWALL", "IFCSLAB"], type="enumeration") facet = ids.entity.create(name=restriction) - case("Entities can be specified as an enumeration 1/3", facet=facet, inst=ifc.createIfcWall(), expected=True) - case("Entities can be specified as an enumeration 2/3", facet=facet, inst=ifc.createIfcSlab(), expected=True) - case("Entities can be specified as an enumeration 3/3", facet=facet, inst=ifc.createIfcBeam(), expected=False) + run("Entities can be specified as an enumeration 1/3", facet=facet, inst=ifc.createIfcWall(), expected=True) + run("Entities can be specified as an enumeration 2/3", facet=facet, inst=ifc.createIfcSlab(), expected=True) + run("Entities can be specified as an enumeration 3/3", facet=facet, inst=ifc.createIfcBeam(), expected=False) # Another example of how restrictions are allowed when matching the IFC class # Note: Regex patterns follow the XSD flavour restriction = ids.restriction.create(options="IFC.*TYPE", type="pattern") facet = ids.entity.create(name=restriction) - case("Entities can be specified as a pattern 1/2", facet=facet, inst=ifc.createIfcWall(), expected=False) - case("Entities can be specified as a pattern 2/2", facet=facet, inst=ifc.createIfcWallType(), expected=True) + run("Entities can be specified as a pattern 1/2", facet=facet, inst=ifc.createIfcWall(), expected=False) + run("Entities can be specified as a pattern 2/2", facet=facet, inst=ifc.createIfcWallType(), expected=True) restriction = ids.restriction.create(options="FOO.*", type="pattern") facet = ids.entity.create(name="IFCWALL", predefinedType=restriction) wall = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall", predefined_type="FOOBAR") wall2 = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall", predefined_type="FOOBAZ") wall3 = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall", predefined_type="BAZFOO") - case("Restrictions an be specified for the predefined type 1/3", facet=facet, inst=wall, expected=True) - case("Restrictions an be specified for the predefined type 2/3", facet=facet, inst=wall2, expected=True) - case("Restrictions an be specified for the predefined type 3/3", facet=facet, inst=wall3, expected=False) + run("Restrictions an be specified for the predefined type 1/3", facet=facet, inst=wall, expected=True) + run("Restrictions an be specified for the predefined type 2/3", facet=facet, inst=wall2, expected=True) + run("Restrictions an be specified for the predefined type 3/3", facet=facet, inst=wall3, expected=False) def test_creating_an_attribute_facet(self): attribute = ids.attribute.create(name="name") @@ -416,46 +421,58 @@ class TestIdsAuthoring(unittest.TestCase): } def test_filtering_using_an_attribute_facet(self): + set_facet("attribute") + ifc = ifcopenshell.file() - # Attribute names that don't exist are never matched facet = ids.attribute.create(name="Foobar") - case("", facet=facet, inst=ifc.createIfcWall(), expected=False) + run("Invalid attribute names always fail", facet=facet, inst=ifc.createIfcWall(), expected=False) - # Attribute names that are either null or empty string are not matched. - # The logic is that unfortunately most BIM users cannot differentiate between the two. facet = ids.attribute.create(name="Name") - case("", facet=facet, inst=ifc.createIfcWall(), expected=False) - case("", facet=facet, inst=ifc.createIfcWall(Name=""), expected=False) - case("", facet=facet, inst=ifc.createIfcWall(Name="Foobar"), expected=True) - # TODO write test case that evaluates empty list / set as False - # TODO write test case that evaluates logical UNKNOWN as False - # TODO write test case that evaluates any bool as True + run("Attributes with a string value should pass", facet=facet, inst=ifc.createIfcWall(Name="Foobar"), expected=True) + run("Attributes with null values always fail", facet=facet, inst=ifc.createIfcWall(), expected=False) + # The logic is that unfortunately most BIM users cannot differentiate between the two. + run("Attributes with empty strings always fail", facet=facet, inst=ifc.createIfcWall(Name=""), expected=False) + facet = ids.attribute.create(name="CountValue") + run("Attributes with a zero number have meaning and should pass", facet=facet, inst=ifc.createIfcQuantityCount(Name="Foobar", CountValue=0), expected=True) - # An object value is truthy - facet = ids.attribute.create(name="OwnerHistory") - assert bool(facet(ifc.createIfcWall())) is False - assert bool(facet(ifc.createIfcWall(OwnerHistory=ifc.createIfcOwnerHistory()))) is True + facet = ids.attribute.create(name="IsCritical") + element = ifc.createIfcTaskTime(IsCritical=True) + run("Attributes with a boolean true should pass", facet=facet, inst=element, expected=True) + element.IsCritical = False + run("Attributes with a boolean false should pass", facet=facet, inst=element, expected=True) + + facet = ids.attribute.create(name="RelatingPriorities") + run("Attributes with an empty list always fail", facet=facet, inst=ifc.createIfcRelConnectsPathElements(RelatingElement=ifc.createIfcWall(), RelatedElement=ifc.createIfcWall(), RelatingPriorities=[], RelatedPriorities=[], RelatedConnectionType="ATSTART", RelatingConnectionType="ATEND"), expected=False) + + facet = ids.attribute.create(name="LayerStyles") + item = ifc.createIfcCartesianPoint([0., 0., 0.]) + layer = ifc.createIfcPresentationLayerWithStyle("Foo", None, [item], None, True, False, False, []) + run("Attributes with an empty set always fail", facet=facet, inst=layer, expected=False) + + layer.LayerOn = "UNKNOWN" + facet = ids.attribute.create(name="LayerOn") + run("Attributes with a logical unknown always fail", facet=facet, inst=layer, expected=False) + + facet = ids.attribute.create(name="ScheduleDuration") + element = ifc.createIfcTaskTime(ScheduleDuration="P0D") + run("Attributes with a zero duration should pass", facet=facet, inst=element, expected=True) + + facet = ids.attribute.create(name="TaskTime") + element = ifc.createIfcTask(IsMilestone=True, TaskTime=ifc.createIfcTaskTime()) + run("Attributes referencing an object should pass", facet=facet, inst=element, expected=True) # Selects are only considered for truthy or falsey facet = ids.attribute.create(name="DiffuseColour") element = ifc.createIfcSurfaceStyleRendering() - assert bool(facet(element)) is False - assert bool(facet(ifc.createIfcSurfaceStyleRendering(DiffuseColour=ifc.createIfcColourRgb()))) is True - assert ( - bool(facet(ifc.createIfcSurfaceStyleRendering(DiffuseColour=ifc.createIfcNormalisedRatioMeasure(0.5)))) - is True - ) + rgb = ifc.createIfcColourRgb(None, 1, 1, 1) + run("Attributes with a select referencing an object should pass", facet=facet, inst=ifc.createIfcSurfaceStyleRendering(SurfaceColour=rgb, ReflectanceMethod="FLAT", DiffuseColour=ifc.createIfcColourRgb(None, 1, 1, 1)), expected=True) + run("Attributes with a select referencing a primitive should pass", facet=facet, inst=ifc.createIfcSurfaceStyleRendering(SurfaceColour=rgb, ReflectanceMethod="FLAT", DiffuseColour=ifc.createIfcNormalisedRatioMeasure(0.5)), expected=True) # When a value is specified, the value shall match case sensitively facet = ids.attribute.create(name="Name", value="Foobar") - case("", facet=facet, inst=ifc.createIfcWall(Name="Foobar"), expected=True) - case("", facet=facet, inst=ifc.createIfcWall(Name="foobar"), expected=False) - case("", facet=facet, inst=ifc.createIfcWall(Name="Foobaz"), expected=False) - - # A value that is 0 is still considered a value, not "null-like", so it is matched - facet = ids.attribute.create(name="Eastings") - case("", facet=facet, inst=ifc.createIfcMapConversion(Eastings=0), expected=True) + run("Attributes should check strings case sensitively 1/2", facet=facet, inst=ifc.createIfcWall(Name="Foobar"), expected=True) + run("Attributes should check strings case sensitively 2/2", facet=facet, inst=ifc.createIfcWall(Name="foobar"), expected=False) # Value checks are meaningless for checking objects, selects, and lists so it always fails facet = ids.attribute.create(name="OwnerHistory", value="Foobar") @@ -475,8 +492,8 @@ class TestIdsAuthoring(unittest.TestCase): # Simple values which must be strings are checked with strict typing. No type casting shall occur. facet = ids.attribute.create(name="Eastings", value="42") - case("", facet=facet, inst=ifc.createIfcMapConversion(Eastings=0), expected=False) - case("", facet=facet, inst=ifc.createIfcMapConversion(Eastings=42), expected=False) + run("", facet=facet, inst=ifc.createIfcMapConversion(Eastings=0), expected=False) + run("", facet=facet, inst=ifc.createIfcMapConversion(Eastings=42), expected=False) # Strict type checking is done with restrictions. This is really ugly, but hopefully hidden to a user. restriction = ids.restriction.create(options=[42], type="enumeration", base="decimal") @@ -485,47 +502,47 @@ class TestIdsAuthoring(unittest.TestCase): # options={"minInclusive": 42, "maxInclusive": 42}, type="bounds", base="decimal" # ) facet = ids.attribute.create(name="Eastings", value=restriction) - case("", facet=facet, inst=ifc.createIfcMapConversion(Eastings=42), expected=True) + run("", facet=facet, inst=ifc.createIfcMapConversion(Eastings=42), expected=True) # Restrictions are allowed for the name restriction = ids.restriction.create(options=".*Name.*", type="pattern") facet = ids.attribute.create(name=restriction) - case("", facet=facet, inst=ifc.createIfcMaterialLayerSet(LayerSetName="Foo"), expected=True) - case("", facet=facet, inst=ifc.createIfcMaterialConstituentSet(Name="Foo"), expected=True) + run("", facet=facet, inst=ifc.createIfcMaterialLayerSet(LayerSetName="Foo"), expected=True) + run("", facet=facet, inst=ifc.createIfcMaterialConstituentSet(Name="Foo"), expected=True) # Restrictions for the name imply that multiple names may be matched. All, not any, must pass the checks. restriction = ids.restriction.create(options=["Name", "Description"], type="enumeration") facet = ids.attribute.create(name=restriction) - case("", facet=facet, inst=ifc.createIfcWall(Name="Foo"), expected=False) - case("", facet=facet, inst=ifc.createIfcWall(Name="Foo", Description="Bar"), expected=True) + run("", facet=facet, inst=ifc.createIfcWall(Name="Foo"), expected=False) + run("", facet=facet, inst=ifc.createIfcWall(Name="Foo", Description="Bar"), expected=True) # Restrictions are allowed for the value restriction = ids.restriction.create(options=["Foo", "Bar"], type="enumeration") facet = ids.attribute.create(name="Name", value=restriction) - case("", facet=facet, inst=ifc.createIfcWall(Name="Foo"), expected=True) - case("", facet=facet, inst=ifc.createIfcWall(Name="Bar"), expected=True) - case("", facet=facet, inst=ifc.createIfcWall(Name="Foobar"), expected=False) + run("", facet=facet, inst=ifc.createIfcWall(Name="Foo"), expected=True) + run("", facet=facet, inst=ifc.createIfcWall(Name="Bar"), expected=True) + run("", facet=facet, inst=ifc.createIfcWall(Name="Foobar"), expected=False) # The facet checks on attributes on the type, which may be inherited by the occurence # TODO attribute inheritance is not defined IFC behaviour facet = ids.attribute.create(name="Description", value="Foobar") - case("", facet=facet, inst=ifc.createIfcWall(Description="Foobar"), expected=True) + run("", facet=facet, inst=ifc.createIfcWall(Description="Foobar"), expected=True) wall = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") wall_type = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWallType") ifcopenshell.api.run("type.assign_type", ifc, related_object=wall, relating_type=wall_type) wall_type.Description = "Foobar" - case("", facet=facet, inst=wall, expected=True) + run("", facet=facet, inst=wall, expected=True) # The facet checks on attributes on the type, which may be overriden by attributes on the occurence # TODO attribute overriding is not defined IFC behaviour facet = ids.attribute.create(name="Description", value="Foobar") - case("", facet=facet, inst=ifc.createIfcWall(Description="Foobar"), expected=True) + run("", facet=facet, inst=ifc.createIfcWall(Description="Foobar"), expected=True) wall = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") wall_type = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWallType") ifcopenshell.api.run("type.assign_type", ifc, related_object=wall, relating_type=wall_type) wall_type.Description = "Foobaz" wall.Description = "Foobar" - case("", facet=facet, inst=wall, expected=True) + run("", facet=facet, inst=wall, expected=True) def test_creating_a_classification_facet(self): facet = ids.classification.create() @@ -581,43 +598,43 @@ class TestIdsAuthoring(unittest.TestCase): # A classification facet with no data matches any present classification facet = ids.classification.create() - case("", facet=facet, inst=element0, expected=False) - case("", facet=facet, inst=element1, expected=True) + run("", facet=facet, inst=element0, expected=False) + run("", facet=facet, inst=element1, expected=True) # Values should match exactly if lightweight classifications are used. facet = ids.classification.create(value="1") - case("", facet=facet, inst=element1, expected=True) + run("", facet=facet, inst=element1, expected=True) # Values should match subreferences if full classifications are used. # E.g. a facet searching for Uniclass EF_25_10 Walls will match Uniclass EF_25_10_25, EF_25_10_30, etc facet = ids.classification.create(value="2") - case("", facet=facet, inst=element22, expected=True) + run("", facet=facet, inst=element22, expected=True) # Systems should match exactly regardless of lightweight or full classifications facet = ids.classification.create(system="Foobar") - case("", facet=facet, inst=project, expected=True) - case("", facet=facet, inst=element0, expected=False) - case("", facet=facet, inst=element1, expected=True) - case("", facet=facet, inst=element11, expected=True) - case("", facet=facet, inst=element22, expected=True) + run("", facet=facet, inst=project, expected=True) + run("", facet=facet, inst=element0, expected=False) + run("", facet=facet, inst=element1, expected=True) + run("", facet=facet, inst=element11, expected=True) + run("", facet=facet, inst=element22, expected=True) # Restrictions can be used for values restriction = ids.restriction.create(options="1.*", type="pattern") facet = ids.classification.create(value=restriction) - case("", facet=facet, inst=element1, expected=True) - case("", facet=facet, inst=element11, expected=True) - case("", facet=facet, inst=element22, expected=False) + run("", facet=facet, inst=element1, expected=True) + run("", facet=facet, inst=element11, expected=True) + run("", facet=facet, inst=element22, expected=False) # Restrictions can be used for systems restriction = ids.restriction.create(options="Foo.*", type="pattern") facet = ids.classification.create(system=restriction) - case("", facet=facet, inst=element0, expected=False) - case("", facet=facet, inst=element1, expected=True) + run("", facet=facet, inst=element0, expected=False) + run("", facet=facet, inst=element1, expected=True) # Specifying both a value and a system means that both (as opposed to either) requirements must be met facet = ids.classification.create(system="Foobar", value="1") - case("", facet=facet, inst=element1, expected=True) - case("", facet=facet, inst=element11, expected=False) + run("", facet=facet, inst=element1, expected=True) + run("", facet=facet, inst=element11, expected=False) # The facet checks on either the type or instance. # IFC doesn't specify how inheritance and overrides work here. Two options: @@ -632,11 +649,11 @@ class TestIdsAuthoring(unittest.TestCase): "classification.add_reference", ifc, product=wall_type, reference=ref22, classification=system ) facet = ids.classification.create(value="11") - case("", facet=facet, inst=wall, expected=True) - case("", facet=facet, inst=wall_type, expected=False) + run("", facet=facet, inst=wall, expected=True) + run("", facet=facet, inst=wall_type, expected=False) facet = ids.classification.create(value="22") - case("", facet=facet, inst=wall, expected=True) - case("", facet=facet, inst=wall_type, expected=True) + run("", facet=facet, inst=wall, expected=True) + run("", facet=facet, inst=wall_type, expected=True) def test_creating_a_property_facet(self): facet = ids.property.create() @@ -683,31 +700,31 @@ class TestIdsAuthoring(unittest.TestCase): # The logic is that unfortunately most BIM users cannot differentiate between the two. facet = ids.property.create(propertySet="Foo_Bar", name="Foo") element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) pset = ifcopenshell.api.run("pset.add_pset", ifc, product=element, name="Foo_Bar") - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foo": None}) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foo": "Bar"}) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) # A simple value checks an exact case-sensitive match facet = ids.property.create(propertySet="Foo_Bar", name="Foo", value="Bar") element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") pset = ifcopenshell.api.run("pset.add_pset", ifc, product=element, name="Foo_Bar") ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foo": "Bar"}) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foo": "Baz"}) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) # Simple values only check string matches facet = ids.property.create(propertySet="Foo_Bar", name="Foo", value="1") element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") pset = ifcopenshell.api.run("pset.add_pset", ifc, product=element, name="Foo_Bar") ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foo": "1"}) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foo": ifc.createIfcInteger(1)}) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) # Restrictions are supported for property sets. If multiple are matched, all must satisfy requirements. restriction = ids.restriction.create(options="Foo_.*", type="pattern") @@ -715,11 +732,11 @@ class TestIdsAuthoring(unittest.TestCase): element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") pset = ifcopenshell.api.run("pset.add_pset", ifc, product=element, name="Foo_Bar") ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foo": "Bar"}) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) pset = ifcopenshell.api.run("pset.add_pset", ifc, product=element, name="Foo_Baz") - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foo": "Bar"}) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) # Restrictions are supported for names. If multiple are matched, all must satisfy requirements. restriction = ids.restriction.create(options="Foo.*", type="pattern") @@ -727,11 +744,11 @@ class TestIdsAuthoring(unittest.TestCase): element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") pset = ifcopenshell.api.run("pset.add_pset", ifc, product=element, name="Foo_Bar") ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foobar": "x"}) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foobar": "x", "Foobaz": "x"}) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foobar": "x", "Foobaz": "y"}) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) # Restrictions are supported for values. If multiple are matched, all must satisfy requirements. restriction1 = ids.restriction.create(options="Foo.*", type="pattern") @@ -740,9 +757,9 @@ class TestIdsAuthoring(unittest.TestCase): element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") pset = ifcopenshell.api.run("pset.add_pset", ifc, product=element, name="Foo_Bar") ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foobar": "x", "Foobaz": "y"}) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foobar": "x", "Foobaz": "z"}) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) # Restrictions may be used to check basic data primitives restriction = ids.restriction.create(options=[42.12], type="enumeration", base="decimal") @@ -750,19 +767,19 @@ class TestIdsAuthoring(unittest.TestCase): element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") pset = ifcopenshell.api.run("pset.add_pset", ifc, product=element, name="Foo_Bar") ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foobar": 42.12}) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) restriction = ids.restriction.create(options=[42], type="enumeration", base="integer") facet = ids.property.create(propertySet="Foo_Bar", name="Foobar", value=restriction) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foobar": 42}) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) restriction = ids.restriction.create(options=[True], type="enumeration", base="boolean") facet = ids.property.create(propertySet="Foo_Bar", name="Foobar", value=restriction) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foobar": True}) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foobar": False}) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) # When measure is not specified, no unit conversion is done and only primitives are checked restriction = ids.restriction.create(options=[42.12], type="enumeration", base="decimal") @@ -770,7 +787,7 @@ class TestIdsAuthoring(unittest.TestCase): element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") pset = ifcopenshell.api.run("pset.add_pset", ifc, product=element, name="Foo_Bar") ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foobar": 42.12}) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) # Measure may be used to specify an IFC data type restriction = ids.restriction.create(options=[2], type="enumeration", base="decimal") @@ -778,9 +795,9 @@ class TestIdsAuthoring(unittest.TestCase): element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") pset = ifcopenshell.api.run("pset.add_pset", ifc, product=element, name="Foo_Bar") ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foo": ifc.createIfcMassMeasure(2)}) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foo": ifc.createIfcTimeMeasure(2)}) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) # Measure also implies that a unit matters, and so a conversion shall take place to SI units restriction = ids.restriction.create(options=[2], type="enumeration", base="decimal") @@ -788,9 +805,9 @@ class TestIdsAuthoring(unittest.TestCase): element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") pset = ifcopenshell.api.run("pset.add_pset", ifc, product=element, name="Foo_Bar") ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foo": ifc.createIfcLengthMeasure(2)}) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foo": ifc.createIfcLengthMeasure(2000)}) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) # The facet checks inherited properties from the type wall = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") @@ -799,8 +816,8 @@ class TestIdsAuthoring(unittest.TestCase): pset = ifcopenshell.api.run("pset.add_pset", ifc, product=wall_type, name="Foo_Bar") ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foo": "Bar"}) facet = ids.property.create(propertySet="Foo_Bar", name="Foo") - case("", facet=facet, inst=wall, expected=True) - case("", facet=facet, inst=wall_type, expected=True) + run("", facet=facet, inst=wall, expected=True) + run("", facet=facet, inst=wall_type, expected=True) # The facet checks overriden properties from the occurrence wall = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") @@ -811,8 +828,8 @@ class TestIdsAuthoring(unittest.TestCase): pset = ifcopenshell.api.run("pset.add_pset", ifc, product=wall, name="Foo_Bar") ifcopenshell.api.run("pset.edit_pset", ifc, pset=pset, properties={"Foo": "Bar"}) facet = ids.property.create(propertySet="Foo_Bar", name="Foo", value="Bar") - case("", facet=facet, inst=wall, expected=True) - case("", facet=facet, inst=wall_type, expected=False) + run("", facet=facet, inst=wall, expected=True) + run("", facet=facet, inst=wall_type, expected=False) def test_creating_a_material_facet(self): facet = ids.material.create() @@ -834,98 +851,98 @@ class TestIdsAuthoring(unittest.TestCase): # A material facet with no data matches any present material facet = ids.material.create() element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) material = ifcopenshell.api.run("material.add_material", ifc) ifcopenshell.api.run("material.assign_material", ifc, product=element, material=material) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) # A value will match a material name or category facet = ids.material.create(value="Foo") element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") material = ifcopenshell.api.run("material.add_material", ifc) ifcopenshell.api.run("material.assign_material", ifc, product=element, material=material) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) material.Name = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) material.Name = "Bar" material.Category = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) # A value will match any material name or category in a material list facet = ids.material.create(value="Foo") element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") material_set = ifcopenshell.api.run("material.add_material_set", ifc, set_type="IfcMaterialList") ifcopenshell.api.run("material.assign_material", ifc, product=element, material=material_set) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) material = ifcopenshell.api.run("material.add_material", ifc) ifcopenshell.api.run("material.add_list_item", ifc, material_list=material_set, material=material) material.Name = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) material.Name = "Bar" material.Category = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) # A value will match any material name or category, or layer name or category in a layer set facet = ids.material.create(value="Foo") element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") material_set = ifcopenshell.api.run("material.add_material_set", ifc, set_type="IfcMaterialLayerSet") ifcopenshell.api.run("material.assign_material", ifc, product=element, material=material_set) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) material = ifcopenshell.api.run("material.add_material", ifc) layer = ifcopenshell.api.run("material.add_layer", ifc, layer_set=material_set, material=material) layer.Name = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) layer.Name = "Bar" layer.Category = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) layer.Category = "Bar" material.Name = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) material.Name = "Bar" material.Category = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) # A value will match any material name or category, or profile name or category in a profile set facet = ids.material.create(value="Foo") element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") material_set = ifcopenshell.api.run("material.add_material_set", ifc, set_type="IfcMaterialProfileSet") ifcopenshell.api.run("material.assign_material", ifc, product=element, material=material_set) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) material = ifcopenshell.api.run("material.add_material", ifc) profile = ifcopenshell.api.run("material.add_profile", ifc, profile_set=material_set, material=material) profile.Name = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) profile.Name = "Bar" profile.Category = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) profile.Category = "Bar" material.Name = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) material.Name = "Bar" material.Category = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) # A value will match any material name or category, or constituent name or category in a constituent set facet = ids.material.create(value="Foo") element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") material_set = ifcopenshell.api.run("material.add_material_set", ifc, set_type="IfcMaterialConstituentSet") ifcopenshell.api.run("material.assign_material", ifc, product=element, material=material_set) - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) material = ifcopenshell.api.run("material.add_material", ifc) constituent = ifcopenshell.api.run( "material.add_constituent", ifc, constituent_set=material_set, material=material ) constituent.Name = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) constituent.Name = "Bar" constituent.Category = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) constituent.Category = "Bar" material.Name = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) material.Name = "Bar" material.Category = "Foo" - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) # The facet will check for inherited materials element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") @@ -935,8 +952,8 @@ class TestIdsAuthoring(unittest.TestCase): ifcopenshell.api.run("material.assign_material", ifc, product=element_type, material=material) material.Name = "Foo" facet = ids.material.create(value="Foo") - case("", facet=facet, inst=element, expected=True) - case("", facet=facet, inst=element_type, expected=True) + run("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element_type, expected=True) # The facet will check for overriden materials element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") @@ -949,8 +966,8 @@ class TestIdsAuthoring(unittest.TestCase): ifcopenshell.api.run("material.assign_material", ifc, product=element, material=material) material.Name = "Foo" facet = ids.material.create(value="Foo") - case("", facet=facet, inst=element, expected=True) - case("", facet=facet, inst=element_type, expected=False) + run("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element_type, expected=False) def test_creating_a_partof_facet(self): facet = ids.partOf.create() @@ -966,15 +983,15 @@ class TestIdsAuthoring(unittest.TestCase): subelement = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcWall") ifcopenshell.api.run("aggregate.assign_object", ifc, product=subelement, relating_object=element) facet = ids.partOf.create(entity="IfcElementAssembly") - case("", facet=facet, inst=element, expected=False) - case("", facet=facet, inst=subelement, expected=True) + run("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=subelement, expected=True) # An IfcElementAssembly strictly checks that the whole is an IfcElementAssembly class element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcSlab") subelement = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcBeam") ifcopenshell.api.run("aggregate.assign_object", ifc, product=subelement, relating_object=element) facet = ids.partOf.create(entity="IfcElementAssembly") - case("", facet=facet, inst=subelement, expected=False) + run("", facet=facet, inst=subelement, expected=False) # A nested subelement still passes so long as one of its parents is an IfcElementAssembly # TODO nononono @@ -984,15 +1001,15 @@ class TestIdsAuthoring(unittest.TestCase): ifcopenshell.api.run("aggregate.assign_object", ifc, product=subelement, relating_object=element) ifcopenshell.api.run("aggregate.assign_object", ifc, product=subsubelement, relating_object=subelement) facet = ids.partOf.create(entity="IfcElementAssembly") - case("", facet=facet, inst=subsubelement, expected=True) + run("", facet=facet, inst=subsubelement, expected=True) # An IfcGroup only checks that a group is assigned without any other logic element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcElementAssembly") group = ifcopenshell.api.run("group.add_group", ifc) facet = ids.partOf.create(entity="IfcGroup") - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) ifcopenshell.api.run("group.assign_group", ifc, product=element, group=group) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) # An IfcGroup can be passed by subtypes # TODO: wrong, subtypes should not be matched @@ -1000,15 +1017,15 @@ class TestIdsAuthoring(unittest.TestCase): group = ifc.createIfcInventory() facet = ids.partOf.create(entity="IfcGroup") ifcopenshell.api.run("group.assign_group", ifc, product=element, group=group) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) # An IfcSystem only checks that a system is assigned without any other logic element = ifcopenshell.api.run("root.create_entity", ifc, ifc_class="IfcElementAssembly") system = ifcopenshell.api.run("system.add_system", ifc) facet = ids.partOf.create(entity="IfcSystem") - case("", facet=facet, inst=element, expected=False) + run("", facet=facet, inst=element, expected=False) ifcopenshell.api.run("system.assign_system", ifc, product=element, system=system) - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) # An IfcSystem allows subtypes # TODO: wrong, subtypes should not be matched @@ -1016,7 +1033,7 @@ class TestIdsAuthoring(unittest.TestCase): system = ifcopenshell.api.run("system.add_system", ifc, ifc_class="IfcDistributionSystem") ifcopenshell.api.run("system.assign_system", ifc, product=element, system=system) facet = ids.partOf.create(entity="IfcSystem") - case("", facet=facet, inst=element, expected=True) + run("", facet=facet, inst=element, expected=True) """ Creating IDS with restrictions """