Add design spec for OpenGL 3D view

Replaces the JavaFX SubScene/MeshView rendering with an OpenGL viewport
(openglfx-jogl, GL 3.3 core), single global VBO, GPU color-picking, and
baked fake shading. Windows/Linux targets; JavaFX 3D path removed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/CheckableTest.java

@@ -31,6 +31,7 @@ import org.junit.Test;
 import de.hft.stuttgart.citydoctor2.check.error.SchematronError;
 import de.hft.stuttgart.citydoctor2.datastructure.Building;
 import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation;
 import de.hft.stuttgart.citydoctor2.datastructure.GeometryType;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Lod;
@@ -48,20 +49,6 @@ public class CheckableTest {
 				return null;
 			}
 
-			@Override
-			public void prepareForChecking() {
-
-			}
-
-			@Override
-			public void clearMetaInformation() {
-
-			}
-
-			@Override
-			public void clearAllContainedCheckResults() {
-			}
-
 			@Override
 			public Class<? extends Checkable> getCheckClass() {
 				return Building.class;
@@ -104,7 +91,7 @@ public class CheckableTest {
 	@Test
 	public void testContainsError() {
 		Building b = new Building();
-		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0);
+		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0, Orientation.OUTWARD);
 		b.addGeometry(geom);
 		assertFalse(b.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
 		assertFalse(b.containsAnyError());
@@ -162,7 +149,7 @@ public class CheckableTest {
 	@Test
 	public void testCollectAllContainedErrors() {
 		Building b = new Building();
-		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0);
+		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0, Orientation.OUTWARD);
 		b.addGeometry(geom);
 		b.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR,
 				new SchematronError(null, null, null, null)));

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/AllPolygonsWrongOrientationErrorTest.java

@@ -30,6 +30,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
 import de.hft.stuttgart.citydoctor2.datastructure.GeometryType;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Lod;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation;
 import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
 import de.hft.stuttgart.quality.model.types.AbstractError;
 import de.hft.stuttgart.quality.model.types.AllPolygonsOrientedWrongError;
@@ -39,7 +40,7 @@ public class AllPolygonsWrongOrientationErrorTest {
 
 	@Test
 	public void testAddToValidationResult() {
-		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2);
+		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD);
 		GmlId gmlId = new GmlId("testId");
 		geom.setGmlId(gmlId);
 		AllPolygonsWrongOrientationError err = new AllPolygonsWrongOrientationError(geom);

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/MultipleConnectedComponentsErrorTest.java

@@ -33,6 +33,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.GeometryType;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Lod;
 import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation;
 import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
 import de.hft.stuttgart.quality.model.properties.PolygonIdListProperty;
 import de.hft.stuttgart.quality.model.types.AbstractError;
@@ -44,7 +45,7 @@ public class MultipleConnectedComponentsErrorTest {
 
 	@Test
 	public void testConvertToQualityAdeDatastructure() {
-		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2);
+		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD);
 		GmlId geomId = new GmlId("geomId");
 		geom.setGmlId(geomId);
 		Polygon p1 = new ConcretePolygon();

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldEdgeErrorTest.java

@@ -33,6 +33,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.GeometryType;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Lod;
 import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation;
 import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
 import de.hft.stuttgart.quality.model.properties.EdgeProperty;
 import de.hft.stuttgart.quality.model.types.AbstractError;
@@ -42,7 +43,7 @@ public class NonManifoldEdgeErrorTest {
 
 	@Test
 	public void testConvertToQualityAdeDatastructure() {
-		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2);
+		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD);
 		GmlId geomId = new GmlId("geomId");
 		geom.setGmlId(geomId);
 		

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/NonManifoldVertexErrorTest.java

@@ -34,6 +34,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Lod;
 import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
 import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation;
 import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
 import de.hft.stuttgart.quality.model.types.AbstractError;
 import de.hft.stuttgart.quality.model.types.ValidationResult;
@@ -42,7 +43,7 @@ public class NonManifoldVertexErrorTest {
 
 	@Test
 	public void testConvertToQualityAdeDatastructure() {
-		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2);
+		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD);
 		GmlId geomId = new GmlId("geomId");
 		geom.setGmlId(geomId);
 		Polygon p1 = new ConcretePolygon();

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/PolygonWrongOrientationErrorTest.java

@@ -33,6 +33,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.GeometryType;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Lod;
 import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation;
 import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
 import de.hft.stuttgart.quality.model.properties.EdgeProperty;
 import de.hft.stuttgart.quality.model.types.AbstractError;
@@ -42,7 +43,7 @@ public class PolygonWrongOrientationErrorTest {
 
 	@Test
 	public void testConvertToQualityAdeDatastructure() {
-		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2);
+		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD);
 		GmlId geomId = new GmlId("geomId");
 		geom.setGmlId(geomId);
 		

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/SolidNotClosedErrorTest.java

@@ -33,6 +33,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.GeometryType;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Lod;
 import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation;
 import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
 import de.hft.stuttgart.quality.model.properties.EdgeProperty;
 import de.hft.stuttgart.quality.model.types.AbstractError;
@@ -42,7 +43,7 @@ public class SolidNotClosedErrorTest {
 
 	@Test
 	public void testConvertToQualityAdeDatastructure() {
-		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2);
+		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD);
 		GmlId geomId = new GmlId("geomId");
 		geom.setGmlId(geomId);
 		

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/SolidSelfIntErrorTest.java

@@ -33,6 +33,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.GeometryType;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Lod;
 import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation;
 import de.hft.stuttgart.citydoctor2.utils.PolygonIntersection;
 import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
 import de.hft.stuttgart.quality.model.types.AbstractError;
@@ -43,7 +44,7 @@ public class SolidSelfIntErrorTest {
 
 	@Test
 	public void testConvertToQualityAdeDatastructure() {
-		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2);
+		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD);
 		GmlId geomId = new GmlId("geomId");
 		geom.setGmlId(geomId);
 		Polygon p1 = new ConcretePolygon();

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/check/error/TooFewPolygonsErrorTest.java

@@ -30,6 +30,7 @@ import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
 import de.hft.stuttgart.citydoctor2.datastructure.GeometryType;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Lod;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation;
 import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
 import de.hft.stuttgart.quality.model.types.AbstractError;
 import de.hft.stuttgart.quality.model.types.SolidTooFewPolygonsError;
@@ -39,7 +40,7 @@ public class TooFewPolygonsErrorTest {
 
 	@Test
 	public void testConvertToQualityAdeDatastructure() {
-		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2);
+		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD2, Orientation.OUTWARD);
 		GmlId geomId = new GmlId("geomId");
 		geom.setGmlId(geomId);
 

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/database/DatabaseSettingsTest.java

+package de.hft.stuttgart.citydoctor2.database;
+
+import org.junit.jupiter.api.Test;
+
+public class DatabaseSettingsTest {
+
+    public void testSetLocation(){
+        String tempdirectory = System.getProperty("java.io.tmpdir");
+        DatabaseSettings.setDBLocation(tempdirectory + "/citydoctor");
+    }
+}

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/database/EmbeddedDataBaseHandlerTest.java

+package de.hft.stuttgart.citydoctor2.database;
+
+import de.hft.stuttgart.citydoctor2.datastructure.Building;
+import de.hft.stuttgart.citydoctor2.datastructure.CityDoctorModel;
+import de.hft.stuttgart.citydoctor2.datastructure.CityObject;
+import de.hft.stuttgart.citydoctor2.datastructure.ConcretePolygon;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
+import de.hft.stuttgart.citydoctor2.datastructure.GeometryTestUtils;
+import de.hft.stuttgart.citydoctor2.datastructure.GeometryType;
+import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
+import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
+import de.hft.stuttgart.citydoctor2.datastructure.Lod;
+import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
+import de.hft.stuttgart.citydoctor2.parser.CityGmlParseException;
+import de.hft.stuttgart.citydoctor2.parser.CityGmlParser;
+import de.hft.stuttgart.citydoctor2.parser.InvalidGmlFileException;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import org.citygml4j.core.model.building.AbstractBuilding;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import java.util.List;
+
+import static de.hft.stuttgart.citydoctor2.database.SerializationTest.assertCityObjectEquality;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+public class EmbeddedDataBaseHandlerTest {
+
+    private final EmbeddedDatabaseHandler handler = new EmbeddedDatabaseHandler(new EmbeddedDatabaseConfiguration());
+
+    @Test
+    public void testTempFileConfiguration(){
+        EmbeddedDatabaseConfiguration tempFileconfig = new EmbeddedDatabaseConfiguration("database",
+                "inTempConfig",1, false,false,
+                false,true);
+        EmbeddedDatabaseHandler tempHandler = new EmbeddedDatabaseHandler(tempFileconfig);
+        assertTrue(tempHandler.getTempFileDBLocation().exists());
+
+    }
+
+    @Test
+    public void testInMemoryConfiguration() throws CityGmlParseException, InvalidGmlFileException {
+        EmbeddedDatabaseConfiguration inMemoryConfig = new EmbeddedDatabaseConfiguration("database",
+                "irrelevant",1, true,false,
+                false,false);
+        EmbeddedDatabaseHandler memHandler = new EmbeddedDatabaseHandler(inMemoryConfig);
+        assertNull(memHandler.getTempFileDBLocation());
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        CityDoctorModel model = CityGmlParser.nestedCityGmlFileParse("src/test/resources/SimpleSolid_SrefBS.gml", config);
+        Building b = model.getBuildings().toList().get(0);
+        assertEquals(0, memHandler.getFeatureCount());
+        memHandler.marshallCityObject(b);
+        assertEquals(1, memHandler.getFeatureCount());
+        CityObject co = memHandler.unmarshallCityObject(b.getGmlId());
+        assertNotNull(co);
+        assertTrue(co instanceof Building);
+    }
+
+    @Test
+    public void testGetBboxIntersectingObjects() {
+        handler.setupFeaturesTable();
+        Building b = new Building();
+        Building b2 = new Building();
+        b2.setGmlObject(Mockito.mock(AbstractBuilding.class));
+        Building b3 = new Building();
+        Building b4 = new Building();
+        b4.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD0));
+
+        Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0, Geometry.Orientation.OUTWARD);
+        ConcretePolygon polygon = new ConcretePolygon();
+        geom.getPolygons().add(polygon);
+        polygon.setParent(geom);
+        LinearRing lr = new LinearRing(LinearRing.LinearRingType.EXTERIOR);
+        polygon.setExteriorRing(lr);
+        Vertex v1 = new Vertex(10, 10, 8);
+        lr.getVertices().add(v1);
+        Vertex v2 = new Vertex(14, 15, 7);
+        lr.getVertices().add(v2);
+        Vertex v3 = new Vertex(14, 15, 3);
+        lr.getVertices().add(v3);
+        Vertex v4 = new Vertex(10, 10, 3);
+        lr.getVertices().add(v4);
+        lr.getVertices().add(v1);
+        geom.updateEdgesAndVertices();
+        b.addGeometry(geom);
+
+
+        Geometry geom2 = new Geometry(GeometryType.SOLID, Lod.LOD0, Geometry.Orientation.OUTWARD);
+        ConcretePolygon polygon2 = new ConcretePolygon();
+        geom2.getPolygons().add(polygon2);
+        polygon2.setParent(geom2);
+        LinearRing lr2 = new LinearRing(LinearRing.LinearRingType.EXTERIOR);
+        polygon2.setExteriorRing(lr2);
+        Vertex v1b2 = new Vertex(6, 6, 8);
+        lr2.getVertices().add(v1b2);
+        Vertex v2b2 = new Vertex(11, 13, 7);
+        lr2.getVertices().add(v2b2);
+        Vertex v3b2 = new Vertex(11, 13, 3);
+        lr2.getVertices().add(v3b2);
+        Vertex v4b2 = new Vertex(6, 6, 3);
+        lr2.getVertices().add(v4b2);
+        lr2.getVertices().add(v1b2);
+        geom2.updateEdgesAndVertices();
+        b2.addGeometry(geom2);
+
+        Geometry geom3 = new Geometry(GeometryType.SOLID, Lod.LOD0, Geometry.Orientation.OUTWARD);
+        ConcretePolygon polygon3 = new ConcretePolygon();
+        geom3.getPolygons().add(polygon3);
+        polygon3.setParent(geom3);
+        LinearRing lr3 = new LinearRing(LinearRing.LinearRingType.EXTERIOR);
+        polygon3.setExteriorRing(lr3);
+        Vertex v1b3 = new Vertex(6, 6, 8);
+        lr3.getVertices().add(v1b3);
+        Vertex v2b3 = new Vertex(10, 9.999, 7);
+        lr3.getVertices().add(v2b3);
+        Vertex v3b3 = new Vertex(10, 9.999, 3);
+        lr3.getVertices().add(v3b3);
+        Vertex v4b3 = new Vertex(6, 6, 3);
+        lr3.getVertices().add(v4b3);
+        lr3.getVertices().add(v1b3);
+        geom3.updateEdgesAndVertices();
+        b3.addGeometry(geom3);
+
+        handler.marshallCityObject(b);
+        handler.marshallCityObject(b2);
+        handler.marshallCityObject(b3);
+        handler.marshallCityObject(b4);
+        assertEquals(4, handler.getFeatureCount());
+
+        List<GmlId> objects = handler.getGeometryCollisionCandidates(b);
+        assertEquals(1, objects.size());
+        assertEquals(4, handler.getFeatureCount());
+
+        CityObject co = handler.unmarshallCityObject(objects.get(0));
+        assertNotNull(co);
+        assertCityObjectEquality(b2, co);
+
+    }
+
+    @Test
+    public void testGetBboxBufferIntersectingObjects() {
+        handler.setupFeaturesTable();
+        Building b = new Building();
+        Building b2 = new Building();
+        b2.setGmlObject(Mockito.mock(AbstractBuilding.class));
+        Building b3 = new Building();
+        Building b4 = new Building();
+        b4.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD0));
+
+
+        Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0, Geometry.Orientation.OUTWARD);
+        ConcretePolygon polygon = new ConcretePolygon();
+        geom.getPolygons().add(polygon);
+        polygon.setParent(geom);
+        LinearRing lr = new LinearRing(LinearRing.LinearRingType.EXTERIOR);
+        polygon.setExteriorRing(lr);
+        Vertex v1 = new Vertex(10, 10, 8);
+        lr.getVertices().add(v1);
+        Vertex v2 = new Vertex(14, 15, 7);
+        lr.getVertices().add(v2);
+        Vertex v3 = new Vertex(14, 15, 3);
+        lr.getVertices().add(v3);
+        Vertex v4 = new Vertex(10, 10, 3);
+        lr.getVertices().add(v4);
+        lr.getVertices().add(v1);
+        geom.updateEdgesAndVertices();
+        b.addGeometry(geom);
+
+
+        Geometry geom2 = new Geometry(GeometryType.SOLID, Lod.LOD0, Geometry.Orientation.OUTWARD);
+        ConcretePolygon polygon2 = new ConcretePolygon();
+        geom2.getPolygons().add(polygon2);
+        polygon2.setParent(geom2);
+        LinearRing lr2 = new LinearRing(LinearRing.LinearRingType.EXTERIOR);
+        polygon2.setExteriorRing(lr2);
+        Vertex v1b2 = new Vertex(6, 6, 8);
+        lr2.getVertices().add(v1b2);
+        Vertex v2b2 = new Vertex(9, 9, 7);
+        lr2.getVertices().add(v2b2);
+        Vertex v3b2 = new Vertex(9, 9, 3);
+        lr2.getVertices().add(v3b2);
+        Vertex v4b2 = new Vertex(6, 6, 3);
+        lr2.getVertices().add(v4b2);
+        lr2.getVertices().add(v1b2);
+        geom2.updateEdgesAndVertices();
+        b2.addGeometry(geom2);
+
+        Geometry geom3 = new Geometry(GeometryType.SOLID, Lod.LOD0, Geometry.Orientation.OUTWARD);
+        ConcretePolygon polygon3 = new ConcretePolygon();
+        geom3.getPolygons().add(polygon3);
+        polygon3.setParent(geom3);
+        LinearRing lr3 = new LinearRing(LinearRing.LinearRingType.EXTERIOR);
+        polygon3.setExteriorRing(lr3);
+        Vertex v1b3 = new Vertex(4, 4, 8);
+        lr3.getVertices().add(v1b3);
+        Vertex v2b3 = new Vertex(8.999, 8.999, 7);
+        lr3.getVertices().add(v2b3);
+        Vertex v3b3 = new Vertex(8.999, 8.999, 3);
+        lr3.getVertices().add(v3b3);
+        Vertex v4b3 = new Vertex(4, 4, 3);
+        lr3.getVertices().add(v4b3);
+        lr3.getVertices().add(v1b3);
+        geom3.updateEdgesAndVertices();
+        b3.addGeometry(geom3);
+
+        handler.marshallCityObject(b);
+        handler.marshallCityObject(b2);
+        handler.marshallCityObject(b3);
+        handler.marshallCityObject(b4);
+        assertEquals(4, handler.getFeatureCount());
+
+        List<GmlId> objects = handler.getBufferCollisionCandidates(b, Math.sqrt(2));
+        assertEquals(1, objects.size());
+        assertEquals(4, handler.getFeatureCount());
+
+        CityObject co = handler.unmarshallCityObject(objects.get(0));
+        assertNotNull(co);
+        assertCityObjectEquality(b2, co);
+
+    }
+
+    @Test
+    public void testMarshallingRoundTripSimpleSolid() throws InvalidGmlFileException, CityGmlParseException {
+            ParserConfiguration config = new ParserConfiguration(8, false);
+            CityDoctorModel model = CityGmlParser.parseCityGmlFile("src/test/resources/SimpleSolid_SrefBS.gml", config);
+
+            Building b = model.getBuildings().toList().get(0);
+            assertNotNull(b);
+            assertEquals(1, handler.getFeatureCount());
+            handler.marshallCityObject(b);
+            assertEquals(1, handler.getFeatureCount());
+
+            CityObject b2 = handler.unmarshallCityObject(b.getGmlId());
+            assertNotNull(b2);
+            assertEquals(1, handler.getFeatureCount());
+
+            assertCityObjectEquality(b, b2);
+
+    }
+
+
+    @Test
+    public void testMarshallingRoundTripFzk() throws InvalidGmlFileException, CityGmlParseException {
+            ParserConfiguration config = new ParserConfiguration(8, false);
+            CityDoctorModel model = CityGmlParser.parseCityGmlFile("src/test/resources/FZK_haus.gml", config);
+
+            Building b = model.getBuildings().toList().get(0);
+            assertNotNull(b);
+            assertEquals(1, handler.getFeatureCount());
+            handler.marshallCityObject(b);
+            assertEquals(1, handler.getFeatureCount());
+
+            CityObject b2 = handler.unmarshallCityObject(b.getGmlId());
+            assertNotNull(b2);
+            assertEquals(1, handler.getFeatureCount());
+
+            assertCityObjectEquality(b, b2);
+
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/database/FeatureCacheTest.java

+package de.hft.stuttgart.citydoctor2.database;
+
+import de.hft.stuttgart.citydoctor2.datastructure.*;
+import org.citygml4j.core.model.building.AbstractBuilding;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.mock;
+
+public class FeatureCacheTest {
+
+
+
+    @Test
+    public void testPut(){
+        FeatureCache cache = new FeatureCache();
+
+        Building b = new Building();
+        b.setGmlObject(mock(AbstractBuilding.class));
+        b.setGmlId(new GmlId("test"));
+        b.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD0));
+
+        assertEquals(0, cache.getTotalFeatureCount());
+        cache.put(b);
+        cache.synchronize();
+
+        assertEquals(1, cache.getTotalFeatureCount());
+    }
+
+    @Test
+    public void testGet(){
+        FeatureCache cache = new FeatureCache();
+
+        assertNull(cache.get(new GmlId("test")));
+        Building b = new Building();
+
+        b.setGmlObject(mock(AbstractBuilding.class));
+        b.setGmlId(new GmlId("test"));
+        b.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD0));
+        assertEquals(0, cache.getTotalFeatureCount());
+        cache.put(b);
+        cache.synchronize();
+
+        CityObject b2 = cache.get(new GmlId("test"));
+        assertEquals(b.getGmlId(), b2.getGmlId());
+    }
+
+    @Test
+    public void testStateHandlingFromIdle(){
+        FeatureCache cache = new FeatureCache();
+        assertEquals(FeatureCache.CacheState.IDLE, cache.getState());
+
+        AutoCloseable parsingContext = cache.startParsingMode();
+        try(parsingContext){
+            assertEquals(FeatureCache.CacheState.PARSING, cache.getState());
+        } catch (Exception e){
+            throw new RuntimeException(e);
+        }
+        assertEquals(FeatureCache.CacheState.IDLE, cache.getState());
+
+        AutoCloseable checkingContext = cache.startCheckingMode();
+        try(checkingContext){
+            assertEquals(FeatureCache.CacheState.CHECKING, cache.getState());
+        } catch (Exception e){
+            throw new RuntimeException(e);
+        }
+        assertEquals(FeatureCache.CacheState.IDLE, cache.getState());
+    }
+
+    @Test
+    public void testCheckingModeStateCollision(){
+        FeatureCache cache = new FeatureCache();
+        assertEquals(FeatureCache.CacheState.IDLE, cache.getState());
+        AutoCloseable checkingContext = cache.startCheckingMode();
+        try(checkingContext){
+            assertEquals(FeatureCache.CacheState.CHECKING, cache.getState());
+            assertThrows(IllegalStateException.class, cache::startParsingMode);
+        } catch (Exception e){
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    public void testParsingModeStateCollision(){
+        FeatureCache cache = new FeatureCache();
+        assertEquals(FeatureCache.CacheState.IDLE, cache.getState());
+        AutoCloseable parsingContext = cache.startParsingMode();
+        try(parsingContext){
+            assertEquals(FeatureCache.CacheState.PARSING, cache.getState());
+            assertThrows(IllegalStateException.class, cache::startCheckingMode);
+        } catch (Exception e){
+            throw new RuntimeException(e);
+        }
+    }
+
+
+}

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/database/SerializationTest.java

+package de.hft.stuttgart.citydoctor2.database;
+
+import de.hft.stuttgart.citydoctor2.datastructure.Building;
+import de.hft.stuttgart.citydoctor2.datastructure.CityDoctorModel;
+import de.hft.stuttgart.citydoctor2.datastructure.CityObject;
+import de.hft.stuttgart.citydoctor2.parser.CityGmlParseException;
+import de.hft.stuttgart.citydoctor2.parser.CityGmlParser;
+import de.hft.stuttgart.citydoctor2.parser.InvalidGmlFileException;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import de.hft.stuttgart.citydoctor2.utils.visitors.CityObjectCollector;
+import org.apache.commons.lang3.SerializationUtils;
+import org.junit.Test;
+
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class SerializationTest {
+
+    static void assertCityObjectEquality(CityObject c1, CityObject c2) {
+        assertEquals(c1.getGmlId(), c2.getGmlId());
+        assertEquals(c1.getFeatureType(), c2.getFeatureType());
+        assertEquals(c1.getGmlObject().getId(), c2.getGmlObject().getId());
+
+        CityObjectCollector collector = new CityObjectCollector();
+        c1.accept(collector);
+        Set<CityObject> coB = collector.getCityObjects();
+        collector = new CityObjectCollector();
+        c2.accept(collector);
+        Set<CityObject> coB2 = collector.getCityObjects();
+        assertEquals(coB.size(), coB2.size());
+    }
+
+    @Test
+    public void testRoundtripSimpleSolid() throws CityGmlParseException, InvalidGmlFileException {
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        CityDoctorModel model = CityGmlParser.parseCityGmlFile("src/test/resources/SimpleSolid_SrefBS.gml", config);
+        Building b = model.getBuildings().toList().get(0);
+        assertNotNull(b);
+        Building b2 = SerializationUtils.roundtrip(b);
+        assertNotNull(b2);
+
+        assertCityObjectEquality(b, b2);
+    }
+
+
+    @Test
+    public void testRoundtripFzk() throws CityGmlParseException, InvalidGmlFileException {
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        CityDoctorModel model = CityGmlParser.parseCityGmlFile("src/test/resources/FZK_haus.gml", config);
+        Building b = model.getBuildings().toList().get(0);
+        assertNotNull(b);
+        Building b2 = SerializationUtils.roundtrip(b);
+
+        assertCityObjectEquality(b, b2);
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingTest.java

@@ -23,36 +23,33 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import de.hft.stuttgart.citydoctor2.utils.visitors.GmlGeometryRebuilder;
 import org.citygml4j.core.model.construction.WallSurface;
 import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty;
 import org.citygml4j.core.util.geometry.GeometryFactory;
 import org.junit.Test;
 import org.mockito.Mockito;
 import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
-import org.xmlobjects.gml.model.geometry.primitives.AbstractRing;
-import org.xmlobjects.gml.model.geometry.primitives.AbstractSolid;
-import org.xmlobjects.gml.model.geometry.primitives.AbstractSurface;
-import org.xmlobjects.gml.model.geometry.primitives.Shell;
-import org.xmlobjects.gml.model.geometry.primitives.Solid;
 import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
-import org.xmlobjects.gml.model.geometry.primitives.SurfaceProperty;
 
-import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
 import de.hft.stuttgart.citydoctor2.check.CheckError;
 import de.hft.stuttgart.citydoctor2.check.CheckId;
 import de.hft.stuttgart.citydoctor2.check.CheckResult;
 import de.hft.stuttgart.citydoctor2.check.ResultStatus;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
 
 public class AbstractBuildingTest {
 
+
 	@Test
 	public void testAccept() {
 		AbstractBuilding ab = createAbstractBuilding();
@@ -62,7 +59,7 @@ public class AbstractBuildingTest {
 		AtomicInteger abCounter = new AtomicInteger(0);
 		AtomicInteger bsCounter = new AtomicInteger(0);
 		AtomicInteger biCounter = new AtomicInteger(0);
-		AbstractCheck c = new AbstractCheck() {
+		CheckableUtilsVisitor c = new CheckableUtilsVisitor() {
 
 			@Override
 			public void check(AbstractBuilding ab) {
@@ -79,7 +76,7 @@ public class AbstractBuildingTest {
 		assertEquals(1, bsCounter.intValue());
 		assertEquals(0, biCounter.intValue());
 
-		AbstractCheck c2 = new AbstractCheck() {
+		CheckableUtilsVisitor c2 = new CheckableUtilsVisitor() {
 
 			@Override
 			public void check(Installation bi) {
@@ -91,73 +88,62 @@ public class AbstractBuildingTest {
 	}
 
 	@Test
-	public void testPrepareForChecking() {
-		Installation biMock = mock(Installation.class);
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-
+	public void testVisitorPropagation() {
 		AbstractBuilding ab = createAbstractBuilding();
-		ab.addBoundarySurface(bsMock);
-		ab.addBuildingInstallation(biMock);
-		ab.prepareForChecking();
-		Mockito.verify(biMock, Mockito.times(1)).prepareForChecking();
-		Mockito.verify(bsMock, Mockito.times(1)).prepareForChecking();
-	}
-
-	@Test
-	public void testClearMetaInformation() {
-		Installation biMock = mock(Installation.class);
-		BoundarySurface bsMock = mock(BoundarySurface.class);
+		BuildingRoom mockRoom = mock(BuildingRoom.class);
+		Installation mockInstallation = mock(Installation.class);
+		BuildingConstructiveElement mockConstructiveElement = mock(BuildingConstructiveElement.class);
+		BuildingRoomFurniture mockBuildingRoomFurniture = mock(BuildingRoomFurniture.class);
+		BuildingUnit mockBuildingUnit = mock(BuildingUnit.class);
+		Storey mockStorey = mock(Storey.class);
+		BoundarySurface mockBSurface = mock(BoundarySurface.class);
+		Geometry mockGeometry = mock(Geometry.class);
+
+		ab.addBuildingRoom(mockRoom);
+		ab.addBuildingInstallation(mockInstallation);
+		ab.addConstructiveElement(mockConstructiveElement);
+		ab.addBuildingRoomFurniture(mockBuildingRoomFurniture);
+		ab.addBuildingUnit(mockBuildingUnit);
+		ab.addStorey(mockStorey);
+		ab.addBoundarySurface(mockBSurface);
+		ab.addGeometry(mockGeometry);
+
+		CheckableUtilsVisitor c = new CheckableUtilsVisitor() {
+		};
+		ab.accept(c);
 
-		AbstractBuilding ab = createAbstractBuilding();
-		ab.addBoundarySurface(bsMock);
-		ab.addBuildingInstallation(biMock);
-		ab.clearMetaInformation();
-		Mockito.verify(biMock, Mockito.times(1)).clearMetaInformation();
-		Mockito.verify(bsMock, Mockito.times(1)).clearMetaInformation();
+		verify(mockRoom).accept(c);
+		verify(mockInstallation).accept(c);
+		verify(mockConstructiveElement).accept(c);
+		verify(mockBuildingRoomFurniture).accept(c);
+		verify(mockBuildingUnit).accept(c);
+		verify(mockStorey).accept(c);
+		verify(mockBSurface).accept(c);
+		verify(mockGeometry).accept(c);
 	}
 
 	@Test
 	public void testContainsError() {
 		AbstractBuilding ab = createAbstractBuilding();
 		assertFalse(ab.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+		assertFalse(ab.containsError(CheckId.C_GE_P_NON_PLANAR));
 		ab.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
 		assertTrue(ab.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
-	}
-
-	@Test
-	public void testContainsErrorInBs() {
-		AbstractBuilding ab = createAbstractBuilding();
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-		ab.addBoundarySurface(bsMock);
-		assertFalse(ab.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
-		Mockito.when(bsMock.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)).thenReturn(true);
+		assertFalse(ab.containsError(CheckId.C_GE_P_NON_PLANAR));
+		ab.addCheckResult(new CheckResult(CheckId.C_GE_P_NON_PLANAR, ResultStatus.OK, mock(CheckError.class)));
 		assertTrue(ab.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+		assertFalse(ab.containsError(CheckId.C_GE_P_NON_PLANAR));
 	}
 
-	@Test
-	public void testContainsErrorInBi() {
-		AbstractBuilding ab = createAbstractBuilding();
-		Installation biMock = mock(Installation.class);
-		ab.addBuildingInstallation(biMock);
-		assertFalse(ab.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
-		Mockito.when(biMock.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)).thenReturn(true);
-		assertTrue(ab.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
-	}
 
 	@Test
 	public void testClearAllContainedCheckResults() {
-		Installation biMock = mock(Installation.class);
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-
 		AbstractBuilding ab = createAbstractBuilding();
+		assertTrue(ab.getAllCheckResults().isEmpty());
 		ab.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
-		ab.addBoundarySurface(bsMock);
-		ab.addBuildingInstallation(biMock);
 
 		assertEquals(1, ab.getAllCheckResults().size());
 		ab.clearAllContainedCheckResults();
-		Mockito.verify(biMock, Mockito.times(1)).clearAllContainedCheckResults();
-		Mockito.verify(bsMock, Mockito.times(1)).clearAllContainedCheckResults();
 		assertTrue(ab.getAllCheckResults().isEmpty());
 	}
 
@@ -172,85 +158,59 @@ public class AbstractBuildingTest {
 		assertTrue(ab.containsAnyError());
 	}
 
-	@Test
-	public void testContainsAnyErrorInBs() {
-		AbstractBuilding ab = createAbstractBuilding();
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-		ab.addBoundarySurface(bsMock);
-		assertFalse(ab.containsAnyError());
-		Mockito.when(bsMock.containsAnyError()).thenReturn(true);
-		assertTrue(ab.containsAnyError());
-	}
-
-	@Test
-	public void testContainsAnyErrorInBi() {
-		AbstractBuilding ab = createAbstractBuilding();
-		Installation biMock = mock(Installation.class);
-		ab.addBuildingInstallation(biMock);
-		assertFalse(ab.containsAnyError());
-		Mockito.when(biMock.containsAnyError()).thenReturn(true);
-		assertTrue(ab.containsAnyError());
-	}
-
 	@Test
 	public void testCollectContainedErrors() {
-		Installation biMock = mock(Installation.class);
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-
 		AbstractBuilding ab = createAbstractBuilding();
-		ab.addBoundarySurface(bsMock);
-		ab.addBuildingInstallation(biMock);
 		ab.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
 		List<CheckError> errors = new ArrayList<>();
 		ab.collectContainedErrors(errors);
-		Mockito.verify(biMock, Mockito.times(1)).collectContainedErrors(errors);
-		Mockito.verify(bsMock, Mockito.times(1)).collectContainedErrors(errors);
 		assertEquals(1, errors.size());
 	}
 
 	@Test
 	public void testReCreateGeometriesSolid() {
-		Geometry geom = GeometryTestUtils.createDummyGeometry(GeometryType.SOLID);
-
 		AbstractBuilding ab = createAbstractBuilding();
 		org.citygml4j.core.model.building.AbstractBuilding gmlAb = new org.citygml4j.core.model.building.Building();
 		ab.setCityGmlBuilding(gmlAb);
-		ab.addGeometry(geom);
+		ab.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
+		ab.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
+		ab.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
+		ab.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD4));
+
 		GeometryFactory factory = GeometryFactory.newInstance();
 		ParserConfiguration config = new ParserConfiguration(8, false);
 		ab.reCreateGeometries(factory, config);
-		AbstractSolid aSolid = gmlAb.getLod2Solid().getObject();
-		assertTrue(aSolid instanceof Solid);
-		Solid solid = (Solid) aSolid;
-		Shell geometry = solid.getExterior().getObject();
-		List<SurfaceProperty> surfaceMember = geometry.getSurfaceMembers();
-		assertEquals(1, surfaceMember.size());
-		AbstractSurface polySurface = surfaceMember.get(0).getObject();
-		assertTrue(polySurface instanceof org.xmlobjects.gml.model.geometry.primitives.Polygon);
-		var gmlPoly = (org.xmlobjects.gml.model.geometry.primitives.Polygon) polySurface;
-		AbstractRing ring = gmlPoly.getExterior().getObject();
-		var gmlRing = (org.xmlobjects.gml.model.geometry.primitives.LinearRing) ring;
-		List<Double> posList = gmlRing.toCoordinateList3D();
-		double[] expectedValues = new double[] { 427583.301, 6003502.571, 9.711, 427583.304, 6003502.574, 9.713,
-				427583.304, 6003502.574, 4.097, 427583.301, 6003502.571, 4.097, 427583.301, 6003502.571, 9.711 };
-		for (int i = 0; i < posList.size(); i++) {
-			assertEquals(expectedValues[i], posList.get(i), 0.00000001);
-		}
+		GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAb.getLod1Solid().getObject());
+		GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAb.getLod2Solid().getObject());
+		GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAb.getLod3Solid().getObject());
+		GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAb.getDeprecatedProperties().getLod4Solid().getObject());
 	}
 
 	@Test
 	public void testReCreateGeometriesMultiSurface() {
-		Geometry geom = GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE);
-
 		AbstractBuilding ab = createAbstractBuilding();
 		org.citygml4j.core.model.building.AbstractBuilding gmlAb = new org.citygml4j.core.model.building.Building();
 		ab.setCityGmlBuilding(gmlAb);
-		ab.addGeometry(geom);
+		ab.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
+		ab.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
+		ab.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+		ab.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+		ab.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+
 		GeometryFactory factory = GeometryFactory.newInstance();
 		ParserConfiguration config = new ParserConfiguration(8, false);
 		ab.reCreateGeometries(factory, config);
+
+		assertNotNull(gmlAb.getLod0MultiSurface());
+		assertNotNull(gmlAb.getLod0MultiSurface().getObject());
+		assertNotNull(gmlAb.getDeprecatedProperties().getLod1MultiSurface());
+		assertNotNull(gmlAb.getDeprecatedProperties().getLod1MultiSurface().getObject());
 		assertNotNull(gmlAb.getLod2MultiSurface());
 		assertNotNull(gmlAb.getLod2MultiSurface().getObject());
+		assertNotNull(gmlAb.getLod3MultiSurface());
+		assertNotNull(gmlAb.getLod3MultiSurface().getObject());
+		assertNotNull(gmlAb.getDeprecatedProperties().getLod4MultiSurface());
+		assertNotNull(gmlAb.getDeprecatedProperties().getLod4MultiSurface().getObject());
 	}
 
 	@Test
@@ -266,7 +226,7 @@ public class AbstractBuildingTest {
 		GeometryFactory factory = GeometryFactory.newInstance();
 		ParserConfiguration config = new ParserConfiguration(8, false);
 		ab.reCreateGeometries(factory, config);
-		Mockito.verify(bsMock).reCreateGeometries(factory, config);
+		Mockito.verify(bsMock).accept(any(GmlGeometryRebuilder.class));
 	}
 
 	@Test
@@ -299,18 +259,15 @@ public class AbstractBuildingTest {
 		org.citygml4j.core.model.building.AbstractBuilding gmlAb = new org.citygml4j.core.model.building.Building();
 		ab.setCityGmlBuilding(gmlAb);
 		ab.reCreateGeometries(factory, config);
-		Mockito.verify(biMock).reCreateGeometries(factory, config);
+		Mockito.verify(biMock).accept(any(GmlGeometryRebuilder.class));
 	}
 
 	@Test
 	public void testUnsetGmlGeometries() {
-		Installation biMock = mock(Installation.class);
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-
 		AbstractBuilding ab = createAbstractBuilding();
-		ab.addBoundarySurface(bsMock);
-		ab.addBuildingInstallation(biMock);
 		org.citygml4j.core.model.building.AbstractBuilding gmlAb = new org.citygml4j.core.model.building.Building();
+		ab.setCityGmlBuilding(gmlAb);
+
 		gmlAb.setLod1Solid(new SolidProperty());
 		gmlAb.setLod2Solid(new SolidProperty());
 		gmlAb.setLod3Solid(new SolidProperty());
@@ -319,10 +276,9 @@ public class AbstractBuildingTest {
 		gmlAb.setLod2MultiSurface(new MultiSurfaceProperty());
 		gmlAb.setLod3MultiSurface(new MultiSurfaceProperty());
 		gmlAb.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty());
-		ab.setCityGmlBuilding(gmlAb);
-		ab.unsetGmlGeometries();
-		Mockito.verify(biMock).unsetGmlGeometries();
-		Mockito.verify(bsMock).unsetGmlGeometries();
+
+		ab.clearGmlGeometries();
+
 		assertNull(gmlAb.getLod1Solid());
 		assertNull(gmlAb.getLod2Solid());
 		assertNull(gmlAb.getLod3Solid());
@@ -340,16 +296,15 @@ public class AbstractBuildingTest {
 	}
 
 	private AbstractBuilding createAbstractBuilding() {
-		AbstractBuilding ab = new AbstractBuilding() {
+		return new AbstractBuilding() {
 			private static final long serialVersionUID = -448362592456318541L;
 
 			@Override
-			public Copyable createCopyInstance() {
+			public CityObject getTopLevelCityObject(){
 				return null;
 			}
 
 		};
-		return ab;
 	}
 
 }

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractRoomTest.java

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
+import de.hft.stuttgart.citydoctor2.check.CheckError;
+import de.hft.stuttgart.citydoctor2.check.CheckId;
+import de.hft.stuttgart.citydoctor2.check.CheckResult;
+import de.hft.stuttgart.citydoctor2.check.ResultStatus;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import org.citygml4j.core.model.core.AbstractSpaceBoundary;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.citygml4j.core.visitor.ObjectVisitor;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
+import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+
+public class AbstractRoomTest {
+
+    AbstractRoom abRoom;
+
+    @Before
+    public void setUp() {
+        abRoom = new AbstractRoom() {
+            @Override
+            public CityObject getTopLevelCityObject() {
+                return null;
+            }
+        };
+    }
+
+    @Test
+    public void testAbstractRoomVisitorPropagation() {
+
+        Installation mockInstallation = Mockito.mock(Installation.class);
+        BoundarySurface mockBoundarySurface = Mockito.mock(BoundarySurface.class);
+        Geometry geometry = Mockito.mock(Geometry.class);
+
+        abRoom.addRoomInstallation(mockInstallation);
+        abRoom.addBoundarySurface(mockBoundarySurface);
+        abRoom.addGeometry(geometry);
+
+        CheckableUtilsVisitor c = new CheckableUtilsVisitor() {
+        };
+        abRoom.accept(c);
+
+        Mockito.verify(mockInstallation).accept(c);
+        Mockito.verify(mockBoundarySurface).accept(c);
+        Mockito.verify(geometry).accept(c);
+    }
+
+    @Test
+    public void testContainsError() {
+        assertFalse(abRoom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        assertFalse(abRoom.containsError(CheckId.C_GE_P_NON_PLANAR));
+        abRoom.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
+        assertTrue(abRoom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        assertFalse(abRoom.containsError(CheckId.C_GE_P_NON_PLANAR));
+        abRoom.addCheckResult(new CheckResult(CheckId.C_GE_P_NON_PLANAR, ResultStatus.OK, mock(CheckError.class)));
+        assertTrue(abRoom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        assertFalse(abRoom.containsError(CheckId.C_GE_P_NON_PLANAR));
+    }
+
+
+    @Test
+    public void testClearAllContainedCheckResults() {
+        abRoom.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
+        assertEquals(1, abRoom.getAllCheckResults().size());
+        abRoom.clearAllContainedCheckResults();
+        assertTrue(abRoom.getAllCheckResults().isEmpty());
+    }
+
+    @Test
+    public void testContainsAnyError() {
+        assertFalse(abRoom.containsAnyError());
+        abRoom.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
+        assertFalse(abRoom.containsAnyError());
+        abRoom.addCheckResult(
+                new CheckResult(CheckId.C_GE_P_INNER_RINGS_NESTED, ResultStatus.ERROR, mock(CheckError.class)));
+        assertTrue(abRoom.containsAnyError());
+    }
+
+    @Test
+    public void testCollectContainedErrors() {
+        abRoom.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
+        List<CheckError> errors = new ArrayList<>();
+        abRoom.collectContainedErrors(errors);
+        assertEquals(1, errors.size());
+    }
+
+    @Test
+    public void testUnsetGmlGeometries() {
+        org.citygml4j.core.model.core.AbstractUnoccupiedSpace gmlAUS = new org.citygml4j.core.model.core.AbstractUnoccupiedSpace() {
+            @Override
+            public void accept(ObjectVisitor visitor) {
+                return;
+            }
+
+            @Override
+            public boolean isValidBoundary(Class<? extends AbstractSpaceBoundary> type) {
+                return false;
+            }
+        };
+
+        gmlAUS.setLod1Solid(new SolidProperty());
+        gmlAUS.setLod2Solid(new SolidProperty());
+        gmlAUS.setLod3Solid(new SolidProperty());
+        gmlAUS.setLod0MultiSurface(new MultiSurfaceProperty());
+        gmlAUS.setLod2MultiSurface(new MultiSurfaceProperty());
+        gmlAUS.setLod3MultiSurface(new MultiSurfaceProperty());
+
+        abRoom.cgmlRoom = gmlAUS;
+        abRoom.clearGmlGeometries();
+
+        assertNull(gmlAUS.getLod1Solid());
+        assertNull(gmlAUS.getLod2Solid());
+        assertNull(gmlAUS.getLod3Solid());
+        assertNull(gmlAUS.getLod0MultiSurface());
+        assertNull(gmlAUS.getLod2MultiSurface());
+        assertNull(gmlAUS.getLod3MultiSurface());
+    }
+
+    @Test
+    public void testReCreateGeometriesSolid() {
+        org.citygml4j.core.model.core.AbstractUnoccupiedSpace gmlAUS = new org.citygml4j.core.model.core.AbstractUnoccupiedSpace() {
+            @Override
+            public void accept(ObjectVisitor visitor) {
+                return;
+            }
+
+            @Override
+            public boolean isValidBoundary(Class<? extends AbstractSpaceBoundary> type) {
+                return false;
+            }
+        };
+
+        abRoom.cgmlRoom = gmlAUS;
+        abRoom.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
+        abRoom.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
+        abRoom.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        abRoom.reCreateGeometries(factory, config);
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAUS.getLod1Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAUS.getLod2Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAUS.getLod3Solid().getObject());
+    }
+
+    @Test
+    public void testReCreateGeometriesMultiSurface() {
+        org.citygml4j.core.model.core.AbstractUnoccupiedSpace gmlAUS = new org.citygml4j.core.model.core.AbstractUnoccupiedSpace() {
+            @Override
+            public void accept(ObjectVisitor visitor) {
+                return;
+            }
+
+            @Override
+            public boolean isValidBoundary(Class<? extends AbstractSpaceBoundary> type) {
+                return false;
+            }
+        };
+        abRoom.cgmlRoom = gmlAUS;
+        abRoom.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
+        abRoom.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+        abRoom.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        abRoom.reCreateGeometries(factory, config);
+
+        assertNotNull(gmlAUS.getLod0MultiSurface());
+        assertNotNull(gmlAUS.getLod0MultiSurface().getObject());
+        assertNotNull(gmlAUS.getLod2MultiSurface());
+        assertNotNull(gmlAUS.getLod2MultiSurface().getObject());
+        assertNotNull(gmlAUS.getLod3MultiSurface());
+        assertNotNull(gmlAUS.getLod3MultiSurface().getObject());
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractTunnelTest.java

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
+import de.hft.stuttgart.citydoctor2.check.CheckError;
+import de.hft.stuttgart.citydoctor2.check.CheckId;
+import de.hft.stuttgart.citydoctor2.check.CheckResult;
+import de.hft.stuttgart.citydoctor2.check.ResultStatus;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.citygml4j.core.visitor.ObjectVisitor;
+import org.junit.Before;
+import org.junit.Test;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
+import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+public class AbstractTunnelTest {
+
+    AbstractTunnel at;
+
+    @Before
+    public void setUp() {
+        at = new AbstractTunnel() {
+            @Override
+            public CityObject getTopLevelCityObject() {
+                return null;
+            }
+        };
+    }
+
+    @Test
+    public void testVisitorPropagation() {
+        Installation mockInstallation = mock(Installation.class);
+        TunnelHollow mockTunnelHollow = mock(TunnelHollow.class);
+        TunnelFurniture mockTunnelFurniture = mock(TunnelFurniture.class);
+        TunnelPart mockTunnelPart = mock(TunnelPart.class);
+        TunnelConstructiveElement mockTunnelConstructiveElement = mock(TunnelConstructiveElement.class);
+        BoundarySurface mockBoundarySurface = mock(BoundarySurface.class);
+        Geometry mockGeometry = mock(Geometry.class);
+
+        at.addTunnelInstallation(mockInstallation);
+        at.addTunnelHollow(mockTunnelHollow);
+        at.addTunnelFurniture(mockTunnelFurniture);
+        at.addTunnelPart(mockTunnelPart);
+        at.addTunnelConstructiveElement(mockTunnelConstructiveElement);
+        at.addBoundarySurface(mockBoundarySurface);
+        at.addGeometry(mockGeometry);
+
+        CheckableUtilsVisitor c = new CheckableUtilsVisitor() {
+        };
+        at.accept(c);
+
+        verify(mockInstallation).accept(c);
+        verify(mockTunnelHollow).accept(c);
+        verify(mockTunnelFurniture).accept(c);
+        verify(mockTunnelPart).accept(c);
+        verify(mockTunnelConstructiveElement).accept(c);
+        verify(mockBoundarySurface).accept(c);
+        verify(mockGeometry).accept(c);
+    }
+
+    @Test
+    public void testContainsError() {
+        assertFalse(at.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        assertFalse(at.containsError(CheckId.C_GE_P_NON_PLANAR));
+        at.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
+        assertTrue(at.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        assertFalse(at.containsError(CheckId.C_GE_P_NON_PLANAR));
+        at.addCheckResult(new CheckResult(CheckId.C_GE_P_NON_PLANAR, ResultStatus.OK, mock(CheckError.class)));
+        assertTrue(at.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        assertFalse(at.containsError(CheckId.C_GE_P_NON_PLANAR));
+    }
+
+
+    @Test
+    public void testClearAllContainedCheckResults() {
+        at.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
+        assertEquals(1, at.getAllCheckResults().size());
+        at.clearAllContainedCheckResults();
+        assertTrue(at.getAllCheckResults().isEmpty());
+    }
+
+    @Test
+    public void testContainsAnyError() {
+        assertFalse(at.containsAnyError());
+        at.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
+        assertFalse(at.containsAnyError());
+        at.addCheckResult(
+                new CheckResult(CheckId.C_GE_P_INNER_RINGS_NESTED, ResultStatus.ERROR, mock(CheckError.class)));
+        assertTrue(at.containsAnyError());
+    }
+
+    @Test
+    public void testCollectContainedErrors() {
+        at.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
+        List<CheckError> errors = new ArrayList<>();
+        at.collectContainedErrors(errors);
+        assertEquals(1, errors.size());
+    }
+
+    @Test
+    public void testUnsetGeometries() {
+        org.citygml4j.core.model.tunnel.AbstractTunnel gmlAt = new org.citygml4j.core.model.tunnel.AbstractTunnel() {
+            @Override
+            public void accept(ObjectVisitor visitor) {
+
+            }
+        };
+        at.setGmlObject(gmlAt);
+
+        gmlAt.setLod0MultiSurface(new MultiSurfaceProperty());
+        gmlAt.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty());
+        gmlAt.setLod2MultiSurface(new MultiSurfaceProperty());
+        gmlAt.setLod3MultiSurface(new MultiSurfaceProperty());
+        gmlAt.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty());
+        gmlAt.setLod1Solid(new SolidProperty());
+        gmlAt.setLod2Solid(new SolidProperty());
+        gmlAt.setLod3Solid(new SolidProperty());
+        gmlAt.getDeprecatedProperties().setLod4Solid(new SolidProperty());
+
+        at.clearGmlGeometries();
+
+        assertNull(gmlAt.getLod0MultiSurface());
+        assertNull(gmlAt.getDeprecatedProperties().getLod1MultiSurface());
+        assertNull(gmlAt.getLod2MultiSurface());
+        assertNull(gmlAt.getLod3MultiSurface());
+        assertNull(gmlAt.getDeprecatedProperties().getLod4MultiSurface());
+        assertNull(gmlAt.getLod1Solid());
+        assertNull(gmlAt.getLod2Solid());
+        assertNull(gmlAt.getLod3Solid());
+        assertNull(gmlAt.getDeprecatedProperties().getLod4Solid());
+    }
+
+    @Test
+    public void testReCreateGeometriesSolid() {
+        org.citygml4j.core.model.tunnel.AbstractTunnel gmlAt = new org.citygml4j.core.model.tunnel.AbstractTunnel() {
+            @Override
+            public void accept(ObjectVisitor visitor) {
+
+            }
+        };
+        at.setGmlObject(gmlAt);
+        at.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
+        at.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
+        at.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
+        at.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD4));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        at.reCreateGeometries(factory, config);
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAt.getLod1Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAt.getLod2Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAt.getLod3Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAt.getDeprecatedProperties().getLod4Solid().getObject());
+    }
+
+    @Test
+    public void testReCreateGeometriesMultiSurface() {
+        org.citygml4j.core.model.tunnel.AbstractTunnel gmlAt = new org.citygml4j.core.model.tunnel.AbstractTunnel() {
+            @Override
+            public void accept(ObjectVisitor visitor) {
+
+            }
+        };
+        at.setGmlObject(gmlAt);
+        at.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
+        at.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
+        at.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+        at.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+        at.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        at.reCreateGeometries(factory, config);
+
+        assertNotNull(gmlAt.getLod0MultiSurface());
+        assertNotNull(gmlAt.getLod0MultiSurface().getObject());
+        assertNotNull(gmlAt.getDeprecatedProperties().getLod1MultiSurface());
+        assertNotNull(gmlAt.getDeprecatedProperties().getLod1MultiSurface().getObject());
+        assertNotNull(gmlAt.getLod2MultiSurface());
+        assertNotNull(gmlAt.getLod2MultiSurface().getObject());
+        assertNotNull(gmlAt.getLod3MultiSurface());
+        assertNotNull(gmlAt.getLod3MultiSurface().getObject());
+        assertNotNull(gmlAt.getDeprecatedProperties().getLod4MultiSurface());
+        assertNotNull(gmlAt.getDeprecatedProperties().getLod4MultiSurface().getObject());
+    }
+
+}
\ No newline at end of file

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BoundarySurfaceTest.java

@@ -23,11 +23,16 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import de.hft.stuttgart.citydoctor2.utils.visitors.ClearResultsVisitor;
+import de.hft.stuttgart.citydoctor2.utils.visitors.GmlGeometryRebuilder;
+import de.hft.stuttgart.citydoctor2.utils.visitors.UnsetGeometriesVisitor;
 import org.citygml4j.core.model.construction.AbstractConstructionSurface;
 import org.citygml4j.core.model.construction.WallSurface;
 import org.citygml4j.core.model.core.AbstractThematicSurface;
@@ -36,22 +41,36 @@ import org.junit.Test;
 import org.mockito.Mockito;
 import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
 
-import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
 import de.hft.stuttgart.citydoctor2.check.CheckError;
 import de.hft.stuttgart.citydoctor2.check.CheckId;
 import de.hft.stuttgart.citydoctor2.check.CheckResult;
 import de.hft.stuttgart.citydoctor2.check.ResultStatus;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 
 public class BoundarySurfaceTest {
 
+	@Test
+	public void testVisitorPropagation() {
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, null);
+		Opening oMock = Mockito.mock(Opening.class);
+		bs.addOpening(oMock);
+
+		CheckableUtilsVisitor c = new CheckableUtilsVisitor() {
+		};
+		bs.accept(c);
+
+		verify(oMock).accept(c);
+	}
+
 	@Test
 	public void testAccept() {
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, null);
 		Opening oMock = Mockito.mock(Opening.class);
 		bs.addOpening(oMock);
 		AtomicInteger bsCounter = new AtomicInteger(0);
-		AbstractCheck c = new AbstractCheck() {
+		CheckableUtilsVisitor c = new CheckableUtilsVisitor() {
 
 			@Override
 			public void check(BoundarySurface bs) {
@@ -59,17 +78,17 @@ public class BoundarySurfaceTest {
 			}
 		};
 		bs.accept(c);
-		Mockito.verify(oMock).accept(c);
+		verify(oMock).accept(c);
 		assertEquals(1, bsCounter.intValue());
 	}
 
 	@Test
 	public void testAcceptWithoutFittingCheck() {
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, null);
 		Opening oMock = Mockito.mock(Opening.class);
 		bs.addOpening(oMock);
 		AtomicInteger bsCounter = new AtomicInteger(0);
-		AbstractCheck c = new AbstractCheck() {
+		CheckableUtilsVisitor c = new CheckableUtilsVisitor() {
 
 			@Override
 			public void check(BridgeObject bo) {
@@ -77,31 +96,23 @@ public class BoundarySurfaceTest {
 			}
 		};
 		bs.accept(c);
-		Mockito.verify(oMock).accept(c);
+		verify(oMock).accept(c);
 		assertEquals(0, bsCounter.intValue());
 	}
 
 	@Test
 	public void testPrepareForChecking() {
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
-		Opening oMock = Mockito.mock(Opening.class);
-		bs.addOpening(oMock);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, null);
+		Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD);
+		Geometry spyGeom = Mockito.spy(geom);
+		bs.addGeometry(spyGeom);
 		bs.prepareForChecking();
-		Mockito.verify(oMock).prepareForChecking();
-	}
-
-	@Test
-	public void testClearMetaInformation() {
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
-		Opening oMock = Mockito.mock(Opening.class);
-		bs.addOpening(oMock);
-		bs.clearMetaInformation();
-		Mockito.verify(oMock).clearMetaInformation();
+		verify(spyGeom).updateEdgesAndVertices();
 	}
 
 	@Test
 	public void testContainsError() {
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, null);
 		assertFalse(bs.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
 		bs.addCheckResult(
 				new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, Mockito.mock(CheckError.class)));
@@ -111,9 +122,9 @@ public class BoundarySurfaceTest {
 
 	@Test
 	public void testContainsErrorInOpening() {
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, null);
 		assertFalse(bs.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
-		Opening o = new Opening(OpeningType.WINDOW, SurfaceFeatureType.BUILDING, bs, null);
+		Opening o = new Opening(OpeningType.WINDOW, bs, null);
 		bs.addOpening(o);
 		o.addCheckResult(
 				new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, Mockito.mock(CheckError.class)));
@@ -123,56 +134,41 @@ public class BoundarySurfaceTest {
 
 	@Test
 	public void testClearAllContainedCheckResults() {
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, null);
 		Opening oMock = Mockito.mock(Opening.class);
 		bs.addCheckResult(
 				new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, Mockito.mock(CheckError.class)));
 		assertFalse(bs.getAllCheckResults().isEmpty());
 		bs.addOpening(oMock);
 		bs.clearAllContainedCheckResults();
-		Mockito.verify(oMock).clearAllContainedCheckResults();
+		verify(oMock).accept(any(ClearResultsVisitor.class));
 		assertTrue(bs.getAllCheckResults().isEmpty());
 	}
 
 	@Test
 	public void testContainsAnyError() {
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
-		Opening oMock = Mockito.mock(Opening.class);
-		bs.addOpening(oMock);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, null);
 		assertFalse(bs.containsAnyError());
-		Mockito.verify(oMock).containsAnyError();
 		bs.addCheckResult(
 				new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, Mockito.mock(CheckError.class)));
 		assertTrue(bs.containsAnyError());
 	}
 
-	@Test
-	public void testContainsAnyErrorInOpeing() {
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
-		Opening oMock = Mockito.mock(Opening.class);
-		bs.addOpening(oMock);
-		Mockito.when(oMock.containsAnyError()).thenReturn(true);
-		assertTrue(bs.containsAnyError());
-	}
 
 	@Test
 	public void testCollectContainedErrors() {
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
-		Opening oMock = Mockito.mock(Opening.class);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, null);
 		bs.addCheckResult(
 				new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, Mockito.mock(CheckError.class)));
-		bs.addOpening(oMock);
-
 		List<CheckError> errors = new ArrayList<>();
 		bs.collectContainedErrors(errors);
 		assertEquals(1, errors.size());
-		Mockito.verify(oMock).collectContainedErrors(errors);
 	}
 
 	@Test
 	public void testReCreateGeometriesWithoutId() {
 		WallSurface ws = new WallSurface();
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, ws);
 		bs.reCreateGeometries(GeometryFactory.newInstance(), new ParserConfiguration(8, false));
 		assertNotNull(ws.getId());
 	}
@@ -181,7 +177,7 @@ public class BoundarySurfaceTest {
 	public void testReCreateGeometriesWithId() {
 		WallSurface ws = new WallSurface();
 		ws.setId("test");
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, ws);
 		bs.reCreateGeometries(GeometryFactory.newInstance(), new ParserConfiguration(8, false));
 		// nothing has changed
 		assertEquals("test", ws.getId());
@@ -191,89 +187,52 @@ public class BoundarySurfaceTest {
 	}
 
 	@Test
-	public void testReCreateGeometriesMultiSurfaceLod2() {
-		WallSurface ws = new WallSurface();
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
-		bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE));
-		bs.reCreateGeometries(GeometryFactory.newInstance(), new ParserConfiguration(8, false));
-		assertNotNull(ws.getLod2MultiSurface());
-		assertNull(ws.getLod3MultiSurface());
-		assertNull(ws.getDeprecatedProperties().getLod4MultiSurface());
-	}
-
-	@Test
-	public void testReCreateGeometriesMultiSurfaceBridgeLod2() {
-		WallSurface ws = new WallSurface();
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BRIDGE, BoundarySurfaceType.WALL, ws);
-		bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE));
-		bs.reCreateGeometries(GeometryFactory.newInstance(), new ParserConfiguration(8, false));
-		assertNotNull(ws.getLod2MultiSurface());
-		assertNull(ws.getLod3MultiSurface());
-		assertNull(ws.getDeprecatedProperties().getLod4MultiSurface());
-	}
-
-	@Test
-	public void testReCreateGeometriesMultiSurfaceBridgeLod3() {
+	public void testReCreateGeometriesMultiSurfaceLod0() {
 		WallSurface ws = new WallSurface();
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BRIDGE, BoundarySurfaceType.WALL, ws);
-		bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, ws);
+		bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
 		bs.reCreateGeometries(GeometryFactory.newInstance(), new ParserConfiguration(8, false));
+		assertNotNull(ws.getLod0MultiSurface());
+		assertNull(ws.getLod1MultiSurface());
 		assertNull(ws.getLod2MultiSurface());
-		assertNotNull(ws.getLod3MultiSurface());
+		assertNull(ws.getLod3MultiSurface());
 		assertNull(ws.getDeprecatedProperties().getLod4MultiSurface());
 	}
 
 	@Test
-	public void testReCreateGeometriesMultiSurfaceBridgeLod4() {
+	public void testReCreateGeometriesMultiSurfaceLod1() {
 		WallSurface ws = new WallSurface();
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BRIDGE, BoundarySurfaceType.WALL, ws);
-		bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, ws);
+		bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
 		bs.reCreateGeometries(GeometryFactory.newInstance(), new ParserConfiguration(8, false));
+		assertNull(ws.getLod0MultiSurface());
+		assertNotNull(ws.getLod1MultiSurface());
 		assertNull(ws.getLod2MultiSurface());
 		assertNull(ws.getLod3MultiSurface());
-		assertNotNull(ws.getDeprecatedProperties().getLod4MultiSurface());
+		assertNull(ws.getDeprecatedProperties().getLod4MultiSurface());
 	}
 
 	@Test
-	public void testReCreateGeometriesMultiSurfaceTunnelLod2() {
+	public void testReCreateGeometriesMultiSurfaceLod2() {
 		WallSurface ws = new WallSurface();
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, ws);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, ws);
 		bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE));
 		bs.reCreateGeometries(GeometryFactory.newInstance(), new ParserConfiguration(8, false));
+		assertNull(ws.getLod0MultiSurface());
+		assertNull(ws.getLod1MultiSurface());
 		assertNotNull(ws.getLod2MultiSurface());
 		assertNull(ws.getLod3MultiSurface());
 		assertNull(ws.getDeprecatedProperties().getLod4MultiSurface());
 	}
 
-	@Test
-	public void testReCreateGeometriesMultiSurfaceTunnelLod3() {
-		WallSurface ws = new WallSurface();
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, ws);
-		bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
-		bs.reCreateGeometries(GeometryFactory.newInstance(), new ParserConfiguration(8, false));
-		assertNull(ws.getLod2MultiSurface());
-		assertNotNull(ws.getLod3MultiSurface());
-		assertNull(ws.getDeprecatedProperties().getLod4MultiSurface());
-	}
-
-	@Test
-	public void testReCreateGeometriesMultiSurfaceTunnelLod4() {
-		WallSurface ws = new WallSurface();
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, ws);
-		bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
-		bs.reCreateGeometries(GeometryFactory.newInstance(), new ParserConfiguration(8, false));
-		assertNull(ws.getLod2MultiSurface());
-		assertNull(ws.getLod3MultiSurface());
-		assertNotNull(ws.getDeprecatedProperties().getLod4MultiSurface());
-	}
-
 	@Test
 	public void testReCreateGeometriesMultiSurfaceLod3() {
 		WallSurface ws = new WallSurface();
-		ws.setId("test");
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+		BoundarySurface bs = new BoundarySurface( BoundarySurfaceType.WALL, ws);
 		bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
 		bs.reCreateGeometries(GeometryFactory.newInstance(), new ParserConfiguration(8, false));
+		assertNull(ws.getLod0MultiSurface());
+		assertNull(ws.getLod1MultiSurface());
 		assertNull(ws.getLod2MultiSurface());
 		assertNotNull(ws.getLod3MultiSurface());
 		assertNull(ws.getDeprecatedProperties().getLod4MultiSurface());
@@ -282,30 +241,21 @@ public class BoundarySurfaceTest {
 	@Test
 	public void testReCreateGeometriesMultiSurfaceLod4() {
 		WallSurface ws = new WallSurface();
-		ws.setId("test");
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, ws);
 		bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
 		bs.reCreateGeometries(GeometryFactory.newInstance(), new ParserConfiguration(8, false));
+		assertNull(ws.getLod0MultiSurface());
+		assertNull(ws.getLod1MultiSurface());
 		assertNull(ws.getLod2MultiSurface());
 		assertNull(ws.getLod3MultiSurface());
 		assertNotNull(ws.getDeprecatedProperties().getLod4MultiSurface());
 	}
 
-	@Test
-	public void testReCreateGeometriesMultiSurfaceLod0() {
-		WallSurface ws = new WallSurface();
-		ws.setId("test");
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
-		bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
-		bs.reCreateGeometries(GeometryFactory.newInstance(), new ParserConfiguration(8, false));
-		assertNotNull(ws.getLod0MultiSurface());
-	}
 
 	@Test(expected = IllegalStateException.class)
 	public void testReCreateGeometriesSolid() {
 		WallSurface ws = new WallSurface();
-		ws.setId("test");
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, ws);
 		bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID));
 		bs.reCreateGeometries(GeometryFactory.newInstance(), new ParserConfiguration(8, false));
 	}
@@ -313,20 +263,19 @@ public class BoundarySurfaceTest {
 	@Test
 	public void testReCreateGeometriesOpenings() {
 		WallSurface ws = new WallSurface();
-		ws.setId("test");
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, ws);
 		Opening oMock = Mockito.mock(Opening.class);
 		bs.addOpening(oMock);
 		GeometryFactory factory = GeometryFactory.newInstance();
 		ParserConfiguration config = new ParserConfiguration(8, false);
 		bs.reCreateGeometries(factory, config);
-		Mockito.verify(oMock).reCreateGeometries(factory, config);
+		verify(oMock).accept(any(GmlGeometryRebuilder.class));
 	}
 
 	@Test
 	public void testGetGmlObject() {
 		WallSurface ws = new WallSurface();
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, ws);
 		assertEquals(ws, bs.getGmlObject());
 	}
 
@@ -339,43 +288,11 @@ public class BoundarySurfaceTest {
 		assertNotNull(ws.getLod2MultiSurface());
 		assertNotNull(ws.getLod3MultiSurface());
 		assertNotNull(ws.getDeprecatedProperties().getLod4MultiSurface());
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, ws);
 		Opening oMock = Mockito.mock(Opening.class);
 		bs.addOpening(oMock);
-		bs.unsetGmlGeometries();
-		Mockito.verify(oMock).unsetGmlGeometries();
-		assertNull(ws.getLod2MultiSurface());
-		assertNull(ws.getLod3MultiSurface());
-		assertNull(ws.getDeprecatedProperties().getLod4MultiSurface());
-	}
-
-	@Test
-	public void testUnsetGmlGeometriesBridge() {
-		WallSurface ws = new WallSurface();
-		ws.setLod2MultiSurface(new MultiSurfaceProperty());
-		ws.setLod3MultiSurface(new MultiSurfaceProperty());
-		ws.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty());
-		assertNotNull(ws.getLod2MultiSurface());
-		assertNotNull(ws.getLod3MultiSurface());
-		assertNotNull(ws.getDeprecatedProperties().getLod4MultiSurface());
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BRIDGE, BoundarySurfaceType.WALL, ws);
-		bs.unsetGmlGeometries();
-		assertNull(ws.getLod2MultiSurface());
-		assertNull(ws.getLod3MultiSurface());
-		assertNull(ws.getDeprecatedProperties().getLod4MultiSurface());
-	}
-
-	@Test
-	public void testUnsetGmlGeometriesTunnel() {
-		WallSurface ws = new WallSurface();
-		ws.setLod2MultiSurface(new MultiSurfaceProperty());
-		ws.setLod3MultiSurface(new MultiSurfaceProperty());
-		ws.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty());
-		assertNotNull(ws.getLod2MultiSurface());
-		assertNotNull(ws.getLod3MultiSurface());
-		assertNotNull(ws.getDeprecatedProperties().getLod4MultiSurface());
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, ws);
-		bs.unsetGmlGeometries();
+		bs.accept(new UnsetGeometriesVisitor());
+		verify(oMock).accept(any(UnsetGeometriesVisitor.class));
 		assertNull(ws.getLod2MultiSurface());
 		assertNull(ws.getLod3MultiSurface());
 		assertNull(ws.getDeprecatedProperties().getLod4MultiSurface());
@@ -383,7 +300,7 @@ public class BoundarySurfaceTest {
 
 	@Test
 	public void testGetFeatureType() {
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, null);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, null);
 		assertEquals(FeatureType.BOUNDARY_SURFACE, bs.getFeatureType());
 	}
 
@@ -393,17 +310,11 @@ public class BoundarySurfaceTest {
 		BoundarySurface bs = new BoundarySurface(aco);
 		assertEquals(aco, bs.getGmlObject());
 	}
-	
-	@Test
-	public void testSetFeatureType() {
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, null);
-		bs.setFeatureType(SurfaceFeatureType.BRIDGE);
-		assertEquals(SurfaceFeatureType.BRIDGE, bs.getSurfaceFeatureType());
-	}
+
 
 	@Test
 	public void testSetType() {
-		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, null);
+		BoundarySurface bs = new BoundarySurface(BoundarySurfaceType.WALL, null);
 		bs.setType(BoundarySurfaceType.ROOF);
 		assertEquals(BoundarySurfaceType.ROOF, bs.getType());
 	}

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BridgeConstructiveElementTest.java

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.citygml4j.core.model.construction.WallSurface;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.junit.jupiter.api.Test;
+
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+
+class BridgeConstructiveElementTest {
+
+	@Test
+	void testBoundarySurfaceGeometryRecreation() {
+		WallSurface wallSurface = new WallSurface();
+		BoundarySurface surface = new BoundarySurface(wallSurface);
+		surface.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+		
+		var gmlBce = new org.citygml4j.core.model.bridge.BridgeConstructiveElement();
+		BridgeConstructiveElement bce = new BridgeConstructiveElement(gmlBce);
+		bce.addBoundarySurface(surface);
+		
+		assertNull(wallSurface.getLod2MultiSurface());
+		GeometryFactory factory = GeometryFactory.newInstance();
+		ParserConfiguration config = new ParserConfiguration(8, false);
+		bce.reCreateGeometries(factory, config);
+		assertNotNull(wallSurface.getLod2MultiSurface());
+	}
+
+}

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BridgeObjectTest.java

@@ -22,36 +22,43 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.citygml4j.core.model.bridge.AbstractBridge;
-import org.citygml4j.core.model.bridge.Bridge;
 import org.citygml4j.core.model.deprecated.bridge.DeprecatedPropertiesOfAbstractBridge;
 import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.citygml4j.core.visitor.ObjectVisitor;
 import org.junit.Test;
+import org.mockito.Mockito;
 
-import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
 import de.hft.stuttgart.citydoctor2.check.CheckError;
 import de.hft.stuttgart.citydoctor2.check.CheckId;
 import de.hft.stuttgart.citydoctor2.check.CheckResult;
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
 import de.hft.stuttgart.citydoctor2.check.ResultStatus;
 import de.hft.stuttgart.citydoctor2.datastructure.BridgeObject.BridgeType;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import de.hft.stuttgart.citydoctor2.utils.visitors.UnsetGeometriesVisitor;
 
 public class BridgeObjectTest {
 
+
 	@Test
 	public void testAccept() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
+		BridgeObject bo = new BridgeObject(mock(AbstractBridge.class));
 		bo.addBoundarySurface(new BoundarySurface(null));
 		AtomicInteger boCounter = new AtomicInteger(0);
 		AtomicInteger bsCounter = new AtomicInteger(0);
-		AbstractCheck c = new AbstractCheck() {
+		CheckableUtilsVisitor c = new CheckableUtilsVisitor() {
 
 			@Override
 			public void check(BridgeObject bo) {
@@ -68,216 +75,171 @@ public class BridgeObjectTest {
 		assertEquals(1, bsCounter.intValue());
 
 		AtomicInteger boCounter2 = new AtomicInteger(0);
-		c = new AbstractCheck();
+		c = new CheckableUtilsVisitor() {
+		};
 		bo.accept(c);
 		assertEquals(0, boCounter2.intValue());
 	}
 
 	@Test
-	public void testPrepareForChecking() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
+	public void testVisitorPropagation() {
+		BridgeObject bo = new BridgeObject(mock(AbstractBridge.class));
+
+		BridgeObject partMock = mock(BridgeObject.class);
+		BridgeRoom mockRoom = mock(BridgeRoom.class);
+		BridgeRoomFurniture mockFurn = mock(BridgeRoomFurniture.class);
+		BridgeConstructiveElement ceMock = mock(BridgeConstructiveElement.class);
+		Installation instMock = mock(Installation.class);
 		BoundarySurface bsMock = mock(BoundarySurface.class);
+		Geometry geomMock = mock(Geometry.class);
+
+		bo.addBridgePart(partMock);
+		bo.addBridgeRoom(mockRoom);
+		bo.addBridgeFurniture(mockFurn);
+		bo.addConstructiveElement(ceMock);
+		bo.addBridgeInstallation(instMock);
 		bo.addBoundarySurface(bsMock);
-		bo.prepareForChecking();
-		verify(bsMock).prepareForChecking();
+		bo.addGeometry(geomMock);
+
+		CheckableUtilsVisitor c = new CheckableUtilsVisitor() {
+		};
+		bo.accept(c);
+
+		verify(partMock).accept(c);
+		verify(mockRoom).accept(c);
+		verify(mockFurn).accept(c);
+		verify(ceMock).accept(c);
+		verify(instMock).accept(c);
+		verify(bsMock).accept(c);
+		verify(geomMock).accept(c);
 	}
 
 	@Test
-	public void testClearMetaInformation() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-		bo.addBoundarySurface(bsMock);
-		bo.clearMetaInformation();
-		verify(bsMock).clearMetaInformation();
+	public void testPrepareForChecking() {
+		BridgeObject bo = new BridgeObject(mock(AbstractBridge.class));
+		Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD);
+		Geometry spyGeom = Mockito.spy(geom);
+
+		bo.addGeometry(spyGeom);
+		bo.prepareForChecking();
+
+		verify(spyGeom).updateEdgesAndVertices();
 	}
 
 	@Test
 	public void testContainsError() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
+		BridgeObject bo = new BridgeObject(mock(AbstractBridge.class));
 		assertFalse(bo.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+		assertFalse(bo.containsError(CheckId.C_GE_P_NON_PLANAR));
 		bo.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
 		assertTrue(bo.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
-	}
-
-	@Test
-	public void testContainsError2() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-		bo.addBoundarySurface(bsMock);
-		assertFalse(bo.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
-		when(bsMock.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)).thenReturn(true);
+		assertFalse(bo.containsError(CheckId.C_GE_P_NON_PLANAR));
+		bo.addCheckResult(new CheckResult(CheckId.C_GE_P_NON_PLANAR, ResultStatus.OK, mock(CheckError.class)));
 		assertTrue(bo.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+		assertFalse(bo.containsError(CheckId.C_GE_P_NON_PLANAR));
 	}
 
+
 	@Test
 	public void testClearAllContainedCheckResults() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-		bo.addBoundarySurface(bsMock);
+		BridgeObject bo = new BridgeObject(mock(AbstractBridge.class));
+		bo.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
+
+		assertEquals(1, bo.getAllCheckResults().size());
 		bo.clearAllContainedCheckResults();
-		verify(bsMock).clearAllContainedCheckResults();
+		assertTrue(bo.getAllCheckResults().isEmpty());
 	}
 
 	@Test
 	public void testContainsAnyError() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-		bo.addBoundarySurface(bsMock);
-		bo.containsAnyError();
-		verify(bsMock).containsAnyError();
-		
-		when(bsMock.containsAnyError()).thenReturn(true);
+		BridgeObject bo = new BridgeObject(mock(AbstractBridge.class));
+		assertFalse(bo.containsAnyError());
+		bo.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.OK, null));
+		assertFalse(bo.containsAnyError());
+		bo.addCheckResult(
+				new CheckResult(CheckId.C_GE_P_INNER_RINGS_NESTED, ResultStatus.ERROR, mock(CheckError.class)));
 		assertTrue(bo.containsAnyError());
-		
-		BridgeObject bo2 = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		bo2.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
-		assertTrue(bo2.containsAnyError());
 	}
 
 	@Test
 	public void testCollectContainedErrors() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-		bo.addBoundarySurface(bsMock);
-		ArrayList<CheckError> errors = new ArrayList<>();
+		BridgeObject bo = new BridgeObject(mock(AbstractBridge.class));
+		bo.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
+		List<CheckError> errors = new ArrayList<>();
 		bo.collectContainedErrors(errors);
-		verify(bsMock).collectContainedErrors(errors);
+		assertEquals(1, errors.size());
 	}
 
 	@Test
-	public void testReCreateGeometries() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-		bo.addBoundarySurface(bsMock);
-		GeometryFactory factoryMock = mock(GeometryFactory.class);
-		ParserConfiguration configMock = mock(ParserConfiguration.class);
-		bo.reCreateGeometries(factoryMock, configMock);
-		verify(bsMock).reCreateGeometries(factoryMock, configMock);
-	}
-	
-	@Test
-	public void testReCreateGeometriesMultiSurfaceLod1() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		Geometry geom = GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1);
-		AbstractBridge ab = new Bridge();
-		bo.setGmlObject(ab);
-		bo.addGeometry(geom);
-		GeometryFactory factory = GeometryFactory.newInstance();
-		ParserConfiguration config = new ParserConfiguration(8, false);
-		bo.reCreateGeometries(factory, config);
-		assertNotNull(ab.getDeprecatedProperties().getLod1MultiSurface());
-		assertNotNull(ab.getDeprecatedProperties().getLod1MultiSurface().getObject());
+	public void testReCreateGeometriesSolid() {
+		org.citygml4j.core.model.bridge.AbstractBridge gmlBr = new AbstractBridge() {
+			@Override
+			public void accept(ObjectVisitor visitor) {
+
+			}
+		};
+		BridgeObject bo = new BridgeObject(gmlBr);
+		bo.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
+		bo.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
+		bo.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
+		bo.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD4));
 
-	}
-	
-	@Test
-	public void testReCreateGeometriesMultiSurfaceLod2() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		Geometry geom = GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2);
-		AbstractBridge ab = new Bridge();
-		bo.setGmlObject(ab);
-		bo.addGeometry(geom);
-		GeometryFactory factory = GeometryFactory.newInstance();
-		ParserConfiguration config = new ParserConfiguration(8, false);
-		bo.reCreateGeometries(factory, config);
-		assertNotNull(ab.getLod2MultiSurface());
-		assertNotNull(ab.getLod2MultiSurface().getObject());
-	}
-	
-	@Test
-	public void testReCreateGeometriesMultiSurfaceLod3() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		Geometry geom = GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3);
-		AbstractBridge ab = new Bridge();
-		bo.setGmlObject(ab);
-		bo.addGeometry(geom);
-		GeometryFactory factory = GeometryFactory.newInstance();
-		ParserConfiguration config = new ParserConfiguration(8, false);
-		bo.reCreateGeometries(factory, config);
-		assertNotNull(ab.getLod3MultiSurface());
-		assertNotNull(ab.getLod3MultiSurface().getObject());
-	}
-	
-	@Test
-	public void testReCreateGeometriesMultiSurfaceLod4() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		Geometry geom = GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4);
-		AbstractBridge ab = new Bridge();
-		bo.setGmlObject(ab);
-		bo.addGeometry(geom);
-		GeometryFactory factory = GeometryFactory.newInstance();
-		ParserConfiguration config = new ParserConfiguration(8, false);
-		bo.reCreateGeometries(factory, config);
-		assertNotNull(ab.getDeprecatedProperties().getLod4MultiSurface());
-		assertNotNull(ab.getDeprecatedProperties().getLod4MultiSurface().getObject());
-	}
-	
-	@Test
-	public void testReCreateGeometriesSolidLod1() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		Geometry geom = GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1);
-		AbstractBridge ab = new Bridge();
-		bo.setGmlObject(ab);
-		bo.addGeometry(geom);
-		GeometryFactory factory = GeometryFactory.newInstance();
-		ParserConfiguration config = new ParserConfiguration(8, false);
-		bo.reCreateGeometries(factory, config);
-		assertNotNull(ab.getLod1Solid());
-		assertNotNull(ab.getLod1Solid().getObject());
-	}
-	
-	@Test
-	public void testReCreateGeometriesSolidLod2() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		Geometry geom = GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2);
-		AbstractBridge ab = new Bridge();
-		bo.setGmlObject(ab);
-		bo.addGeometry(geom);
-		GeometryFactory factory = GeometryFactory.newInstance();
-		ParserConfiguration config = new ParserConfiguration(8, false);
-		bo.reCreateGeometries(factory, config);
-		assertNotNull(ab.getLod2Solid());
-		assertNotNull(ab.getLod2Solid().getObject());
-	}
-	
-	@Test
-	public void testReCreateGeometriesSolidLod3() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		Geometry geom = GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3);
-		AbstractBridge ab = new Bridge();
-		bo.setGmlObject(ab);
-		bo.addGeometry(geom);
 		GeometryFactory factory = GeometryFactory.newInstance();
 		ParserConfiguration config = new ParserConfiguration(8, false);
 		bo.reCreateGeometries(factory, config);
-		assertNotNull(ab.getLod3Solid());
-		assertNotNull(ab.getLod3Solid().getObject());
+		GeometryTestUtils.assertSolidMatchesExpectedValues(gmlBr.getLod1Solid().getObject());
+		GeometryTestUtils.assertSolidMatchesExpectedValues(gmlBr.getLod2Solid().getObject());
+		GeometryTestUtils.assertSolidMatchesExpectedValues(gmlBr.getLod3Solid().getObject());
+		GeometryTestUtils.assertSolidMatchesExpectedValues(gmlBr.getDeprecatedProperties().getLod4Solid().getObject());
 	}
-	
+
 	@Test
-	public void testReCreateGeometriesSolidLod4() {
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, mock(AbstractBridge.class));
-		Geometry geom = GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD4);
-		AbstractBridge ab = new Bridge();
-		bo.setGmlObject(ab);
-		bo.addGeometry(geom);
+	public void testReCreateGeometriesMultiSurface() {
+		org.citygml4j.core.model.bridge.AbstractBridge gmlBr = new AbstractBridge() {
+			@Override
+			public void accept(ObjectVisitor visitor) {
+
+			}
+		};
+		BridgeObject bo = new BridgeObject(gmlBr);
+		bo.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
+		bo.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
+		bo.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+		bo.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+		bo.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+
 		GeometryFactory factory = GeometryFactory.newInstance();
 		ParserConfiguration config = new ParserConfiguration(8, false);
 		bo.reCreateGeometries(factory, config);
-		assertNotNull(ab.getDeprecatedProperties().getLod4Solid());
-		assertNotNull(ab.getDeprecatedProperties().getLod4Solid().getObject());
+
+		assertNotNull(gmlBr.getLod0MultiSurface());
+		assertNotNull(gmlBr.getLod0MultiSurface().getObject());
+		assertNotNull(gmlBr.getDeprecatedProperties().getLod1MultiSurface());
+		assertNotNull(gmlBr.getDeprecatedProperties().getLod1MultiSurface().getObject());
+		assertNotNull(gmlBr.getLod2MultiSurface());
+		assertNotNull(gmlBr.getLod2MultiSurface().getObject());
+		assertNotNull(gmlBr.getLod3MultiSurface());
+		assertNotNull(gmlBr.getLod3MultiSurface().getObject());
+		assertNotNull(gmlBr.getDeprecatedProperties().getLod4MultiSurface());
+		assertNotNull(gmlBr.getDeprecatedProperties().getLod4MultiSurface().getObject());
 	}
 
+
 	@Test
 	public void testUnsetGmlGeometries() {
 		AbstractBridge abMock = mock(AbstractBridge.class);
 		DeprecatedPropertiesOfAbstractBridge propsMock = mock(DeprecatedPropertiesOfAbstractBridge.class);
 		when(abMock.getDeprecatedProperties()).thenReturn(propsMock);
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, abMock);
+		BridgeObject bo = new BridgeObject(abMock);
 		BoundarySurface bsMock = mock(BoundarySurface.class);
 		bo.addBoundarySurface(bsMock);
-		
-		bo.unsetGmlGeometries();
+		doAnswer(invocation -> {
+			bsMock.unsetGmlGeometries();
+			return null;
+		}).when(bsMock).accept(any(UnsetGeometriesVisitor.class));
+
+		bo.accept(new UnsetGeometriesVisitor());
+		verify(bsMock).accept(any(UnsetGeometriesVisitor.class));
 		verify(bsMock).unsetGmlGeometries();
 		verify(propsMock).setLod1MultiSurface(null);
 		verify(abMock).setLod2MultiSurface(null);
@@ -293,14 +255,14 @@ public class BridgeObjectTest {
 	@Test
 	public void testGetFeatureType() {
 		AbstractBridge abMock = mock(AbstractBridge.class);
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, abMock);
+		BridgeObject bo = new BridgeObject(abMock);
 		assertEquals(FeatureType.BRIDGE, bo.getFeatureType());
 	}
 
 	@Test
 	public void testGetType() {
 		AbstractBridge abMock = mock(AbstractBridge.class);
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, abMock);
+		BridgeObject bo = new BridgeObject( abMock);
 		assertEquals(BridgeType.BRIDGE, bo.getType());
 		bo.setType(BridgeType.BRIDGE_PART);
 		assertEquals(BridgeType.BRIDGE_PART, bo.getType());
@@ -309,7 +271,7 @@ public class BridgeObjectTest {
 	@Test
 	public void testGetGmlObject() {
 		AbstractBridge abMock = mock(AbstractBridge.class);
-		BridgeObject bo = new BridgeObject(BridgeType.BRIDGE, abMock);
+		BridgeObject bo = new BridgeObject(abMock);
 		assertEquals(abMock, bo.getGmlObject());
 		AbstractBridge abMock2 = mock(AbstractBridge.class);
 		bo.setGmlObject(abMock2);

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BuildingTest.java

@@ -22,11 +22,17 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
+import de.hft.stuttgart.citydoctor2.check.CheckableUtilsVisitor;
 import org.citygml4j.core.model.construction.RoofSurface;
 import org.junit.Test;
+import org.mockito.Mockito;
 import org.xmlobjects.gml.model.basictypes.Code;
 
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry.Orientation;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
 import de.hft.stuttgart.citydoctor2.utils.Copy;
 
@@ -46,20 +52,20 @@ public class BuildingTest {
 		Vertex v2 = new Vertex(2, 0, 0);
 		LinearRing lr = new LinearRing(LinearRingType.EXTERIOR);
 		ConcretePolygon p = new ConcretePolygon();
+		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0, Orientation.OUTWARD);
+		geom.addPolygon(p);
 		p.setExteriorRing(lr);
 		lr.addVertex(v1);
 		lr.addVertex(v2);
 		lr.addVertex(v1);
-		Geometry geom = new Geometry(GeometryType.SOLID, Lod.LOD0);
-		geom.addPolygon(p);
 		geom.updateEdgesAndVertices();
 		b.addGeometry(geom);
 		
 		b.setCityGmlBuilding(createCityGmlBuilding());
 		RoofSurface rs = new RoofSurface();
 		rs.setId("testRoof");
-		BoundarySurface surface = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.ROOF, rs);
-		Geometry geomSurface = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2);
+		BoundarySurface surface = new BoundarySurface(BoundarySurfaceType.ROOF, rs);
+		Geometry geomSurface = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2, Orientation.OUTWARD);
 		geomSurface.addPolygon(new LinkedPolygon(p, geomSurface));
 		geomSurface.updateEdgesAndVertices();
 		surface.addGeometry(geomSurface);
@@ -69,7 +75,8 @@ public class BuildingTest {
 		assertNotSame(b, copy);
 		
 		assertEquals(b.getGmlId(), copy.getGmlId());
-		
+
+		copy.prepareForChecking();
 		Geometry copyGeom = copy.getGeometries().get(0);
 		assertNotSame(geom, copyGeom);
 		
@@ -120,4 +127,42 @@ public class BuildingTest {
 		return b;
 	}
 
+	@Test
+	public void testVisitorPropagation() {
+		Building b = new Building();
+		BuildingPart bp = new BuildingPart(b);
+		BuildingPart spyBp = Mockito.spy(bp);
+		b.getBuildingParts().remove(bp);
+		b.addBuildingPart(spyBp);
+
+		BuildingRoom mockRoom = mock(BuildingRoom.class);
+		Installation mockInstallation = mock(Installation.class);
+		BuildingRoomFurniture mockBuildingRoomFurniture = mock(BuildingRoomFurniture.class);
+		BuildingUnit mockBuildingUnit = mock(BuildingUnit.class);
+		Storey mockStorey = mock(Storey.class);
+
+		b.addBuildingRoom(mockRoom);
+		b.addBuildingInstallation(mockInstallation);
+		b.addBuildingRoomFurniture(mockBuildingRoomFurniture);
+		b.addBuildingUnit(mockBuildingUnit);
+		b.addStorey(mockStorey);
+		bp.addBuildingRoom(mockRoom);
+		bp.addBuildingInstallation(mockInstallation);
+		bp.addBuildingRoomFurniture(mockBuildingRoomFurniture);
+		bp.addBuildingUnit(mockBuildingUnit);
+		bp.addStorey(mockStorey);
+
+
+		CheckableUtilsVisitor c = new CheckableUtilsVisitor() {
+		};
+		b.accept(c);
+
+		verify(spyBp).accept(c);
+		verify(mockRoom, times(2)).accept(c);
+		verify(mockInstallation, times(2)).accept(c);
+		verify(mockBuildingRoomFurniture, times(2)).accept(c);
+		verify(mockBuildingUnit, times(2)).accept(c);
+		verify(mockStorey, times(2)).accept(c);
+	}
+
 }