Refactor: Implement ReCreateGeometries as Visitor

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TrafficAreaObject.java

@@ -27,7 +27,7 @@ public class TrafficAreaObject extends TransportationObject {
     }
 
     @Override
-    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+    public void rebuildGeometries(GeometryFactory factory, ParserConfiguration config) {
         for (Geometry geom : getGeometries()) {
             if (geom instanceof ImplicitGeometryHolder) {
                 continue;

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TrafficSpaceObject.java

@@ -42,7 +42,7 @@ public class TrafficSpaceObject extends TransportationObject {
     }
 
     @Override
-    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+    public void rebuildGeometries(GeometryFactory factory, ParserConfiguration config) {
         for (Geometry geom : getGeometries()) {
             if (geom instanceof ImplicitGeometryHolder) {
                 continue;
@@ -51,9 +51,6 @@ public class TrafficSpaceObject extends TransportationObject {
             AbstractSpace ats = (AbstractSpace) super.getGmlObject();
             setMultiSurfaceAccordingToLod(ats, ms, geom.getLod());
         }
-        for (TrafficAreaObject tao : trafficAreas) {
-            tao.reCreateGeometries(factory, config);
-        }
     }
 
     private void setMultiSurfaceAccordingToLod(AbstractSpace ats, MultiSurface ms, Lod lod) {

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TransportationSpace.java

@@ -43,7 +43,7 @@ public abstract class TransportationSpace extends TransportationObject {
     }
 
     @Override
-    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+    public void rebuildGeometries(GeometryFactory factory, ParserConfiguration config) {
         for (Geometry geom : getGeometries()) {
             if (geom instanceof ImplicitGeometryHolder) {
                 continue;
@@ -61,12 +61,6 @@ public abstract class TransportationSpace extends TransportationObject {
                         + ". Only MultiSurface allowed");
             }
         }
-        for (TrafficSpaceObject spaces : trafficSpaces) {
-            spaces.reCreateGeometries(factory, config);
-        }
-        for (TrafficSpaceObject spaces : auxTrafficSpaces) {
-            spaces.reCreateGeometries(factory, config);
-        }
     }
 
     private void setMultiSurfaceAccordingToLod(AbstractTransportationSpace ats, MultiSurface ms, Lod lod) {

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Tunnel.java

@@ -25,13 +25,6 @@ public class Tunnel extends AbstractTunnel {
         return tunnelParts;
     }
 
-    @Override
-    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
-        super.reCreateGeometries(factory, config);
-        for (TunnelPart tp : tunnelParts) {
-            tp.reCreateGeometries(factory, config);
-        }
-    }
 
     @Override
     public CityObject getTopLevelCityObject() {

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/TunnelConstructiveElement.java

@@ -56,7 +56,7 @@ public class TunnelConstructiveElement extends CityObject {
     }
 
     @Override
-    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+    public void rebuildGeometries(GeometryFactory factory, ParserConfiguration config) {
         // only handles CityGML2 for now
         // unknown which CityGML is handled here
         // need context information to decide
@@ -77,8 +77,20 @@ public class TunnelConstructiveElement extends CityObject {
                 	throw new IllegalStateException("Tunnel constructive element cannot have a composite surface geometry");
             }
         }
+        removeEmptyBoundarySurfaces();
+    }
+
+    private void removeEmptyBoundarySurfaces() {
         for (BoundarySurface bs : boundarySurfaceList) {
-            reCreateBoundarySurface(factory, config, bs);
+            if (bs.getGeometries().isEmpty()) {
+                for (AbstractSpaceBoundaryProperty bsp : gmlTunnelElement.getBoundaries()) {
+                    if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
+                        logger.warn("Found empty boundary surface: {}, removing from feature", bs.getGmlId());
+                        gmlTunnelElement.getBoundaries().remove(bsp);
+                        break;
+                    }
+                }
+            }
         }
     }
 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Vegetation.java

@@ -65,7 +65,7 @@ public class Vegetation extends CityObject {
     }
 
     @Override
-    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+    public void rebuildGeometries(GeometryFactory factory, ParserConfiguration config) {
         for (Geometry geom : getGeometries()) {
             if (geom instanceof ImplicitGeometryHolder) {
                 continue;

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/WaterObject.java

@@ -24,7 +24,10 @@ import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
 import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
 import de.hft.stuttgart.citydoctor2.utils.Copyable;
 import javafx.scene.paint.Color;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.citygml4j.core.model.core.AbstractCityObject;
+import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty;
 import org.citygml4j.core.model.waterbody.WaterBody;
 import org.citygml4j.core.util.geometry.GeometryFactory;
 import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
@@ -44,11 +47,14 @@ public class WaterObject extends CityObject {
     @Serial
     private static final long serialVersionUID = -3821060595086337424L;
 
+    @Serial
+    private static final Logger logger = LogManager.getLogger(WaterObject.class);
+
     private WaterBody gmlWater;
     private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
 
     @Override
-    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+    public void rebuildGeometries(GeometryFactory factory, ParserConfiguration config) {
         for (Geometry geom : getGeometries()) {
             if (geom.getType() == GeometryType.MULTI_SURFACE) {
                 MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
@@ -64,6 +70,21 @@ public class WaterObject extends CityObject {
                 throw new IllegalStateException("Cannot add Solid geometry to WaterBody");
             }
         }
+        removeEmptyBoundarySurfaces();
+    }
+
+    private void removeEmptyBoundarySurfaces() {
+        for (BoundarySurface bs : boundarySurfaceList) {
+            if (bs.getGeometries().isEmpty()) {
+                for (AbstractSpaceBoundaryProperty bsp : gmlWater.getBoundaries()) {
+                    if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
+                        logger.warn("Found empty boundary surface: {}, removing from feature", bs.getGmlId());
+                        gmlWater.getBoundaries().remove(bsp);
+                        break;
+                    }
+                }
+            }
+        }
     }
 
     /**

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/utils/visitors/GmlGeometryRebuilder.java

+package de.hft.stuttgart.citydoctor2.utils.visitors;
+
+import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
+import de.hft.stuttgart.citydoctor2.datastructure.CityObject;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+
+public class GmlGeometryRebuilder extends AbstractCheck {
+
+    private final GeometryFactory factory;
+    private final ParserConfiguration config;
+
+    public GmlGeometryRebuilder(GeometryFactory factory, ParserConfiguration configuration) {
+        this.factory = factory;
+        this.config = configuration;
+    }
+
+    @Override
+    public void check(CityObject cityObject) {
+        cityObject.rebuildGeometries(factory, config);
+    }
+}

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

@@ -48,11 +48,6 @@ public class CheckableTest {
 				return null;
 			}
 
-			@Override
-			public void clearMetaInformation() {
-
-			}
-
 			@Override
 			public void clearAllContainedCheckResults() {
 			}

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

@@ -32,6 +32,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import de.hft.stuttgart.citydoctor2.utils.visitors.GmlGeometryRebuilder;
 import de.hft.stuttgart.citydoctor2.utils.visitors.UnsetGeometriesVisitor;
 import org.citygml4j.core.model.construction.WallSurface;
 import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty;
@@ -57,6 +58,9 @@ import de.hft.stuttgart.citydoctor2.utils.Copyable;
 
 public class AbstractBuildingTest {
 
+	//TODO: Restructure test with new Visitors
+
+
 	@Test
 	public void testAccept() {
 		AbstractBuilding ab = createAbstractBuilding();
@@ -103,6 +107,7 @@ public class AbstractBuildingTest {
 		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);
@@ -110,6 +115,7 @@ public class AbstractBuildingTest {
 		ab.addBuildingUnit(mockBuildingUnit);
 		ab.addStorey(mockStorey);
 		ab.addBoundarySurface(mockBSurface);
+		ab.addGeometry(mockGeometry);
 
 		AbstractCheck c = new AbstractCheck() {
 		};
@@ -121,32 +127,7 @@ public class AbstractBuildingTest {
 		verify(mockBuildingUnit).accept(c);
 		verify(mockStorey).accept(c);
 		verify(mockBSurface).accept(c);
-	}
-
-	@Test
-	public void testPrepareForChecking() {
-		Installation biMock = mock(Installation.class);
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-
-		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);
-
-		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(mockGeometry).accept(c);
 	}
 
 	@Test
@@ -157,25 +138,6 @@ public class AbstractBuildingTest {
 		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);
-		assertTrue(ab.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
-	}
-
-	@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() {
@@ -205,39 +167,12 @@ 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());
 	}
 
@@ -264,8 +199,7 @@ public class AbstractBuildingTest {
 		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 };
+		double[] expectedValues = GeometryTestUtils.getExpectedValues();
 		for (int i = 0; i < posList.size(); i++) {
 			assertEquals(expectedValues[i], posList.get(i), 0.00000001);
 		}
@@ -299,7 +233,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
@@ -332,7 +266,7 @@ 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

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

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
+import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import org.citygml4j.core.visitor.ObjectVisitor;
+import org.junit.Before;
+import org.junit.Test;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiCurveProperty;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
+import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+public class AbstractTunnelTest {
+
+    // TODO: Implement recreateGeometriesTest
+
+    AbstractTunnel at;
+
+    @Before
+    public void setUp() {
+        at = new AbstractTunnel() {
+            @Override
+            public CityObject getTopLevelCityObject() {
+                return null;
+            }
+
+            @Override
+            public Copyable createCopyInstance() {
+                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);
+
+        AbstractCheck c = new AbstractCheck() {
+        };
+        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 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.setLod0MultiCurve(new MultiCurveProperty());
+        gmlAt.setLod2MultiCurve(new MultiCurveProperty());
+        gmlAt.setLod3MultiCurve(new MultiCurveProperty());
+        gmlAt.getDeprecatedProperties().setLod4MultiCurve(new MultiCurveProperty());
+        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.getLod0MultiCurve());
+        assertNull(gmlAt.getLod2MultiCurve());
+        assertNull(gmlAt.getLod3MultiCurve());
+        assertNull(gmlAt.getDeprecatedProperties().getLod4MultiCurve());
+        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 testReCreateGeometry() {
+
+    }
+
+}
\ No newline at end of file

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

@@ -29,6 +29,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 
+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;
@@ -47,6 +48,8 @@ import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 
 public class BoundarySurfaceTest {
 
+	//Todo: Check this class for rework potential with the new Visitors
+
 	@Test
 	public void testAccept() {
 		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
@@ -86,19 +89,11 @@ public class BoundarySurfaceTest {
 	@Test
 	public void testPrepareForChecking() {
 		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
-		Opening oMock = Mockito.mock(Opening.class);
-		bs.addOpening(oMock);
+		Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2);
+		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();
+		Mockito.verify(spyGeom).updateEdgesAndVertices();
 	}
 
 	@Test
@@ -139,36 +134,22 @@ public class BoundarySurfaceTest {
 	@Test
 	public void testContainsAnyError() {
 		BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
-		Opening oMock = Mockito.mock(Opening.class);
-		bs.addOpening(oMock);
 		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);
 		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
@@ -322,7 +303,7 @@ public class BoundarySurfaceTest {
 		GeometryFactory factory = GeometryFactory.newInstance();
 		ParserConfiguration config = new ParserConfiguration(8, false);
 		bs.reCreateGeometries(factory, config);
-		Mockito.verify(oMock).reCreateGeometries(factory, config);
+		Mockito.verify(oMock).accept(any(GmlGeometryRebuilder.class));
 	}
 
 	@Test

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

@@ -31,9 +31,11 @@ import static org.mockito.Mockito.when;
 import java.util.ArrayList;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import de.hft.stuttgart.citydoctor2.utils.visitors.GmlGeometryRebuilder;
 import de.hft.stuttgart.citydoctor2.utils.visitors.UnsetGeometriesVisitor;
 import org.citygml4j.core.model.bridge.AbstractBridge;
 import org.citygml4j.core.model.bridge.Bridge;
+import org.citygml4j.core.model.core.AbstractThematicSurface;
 import org.citygml4j.core.model.deprecated.bridge.DeprecatedPropertiesOfAbstractBridge;
 import org.citygml4j.core.util.geometry.GeometryFactory;
 import org.junit.Test;
@@ -45,9 +47,12 @@ import de.hft.stuttgart.citydoctor2.check.CheckResult;
 import de.hft.stuttgart.citydoctor2.check.ResultStatus;
 import de.hft.stuttgart.citydoctor2.datastructure.BridgeObject.BridgeType;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import org.mockito.Mockito;
 
 public class BridgeObjectTest {
 
+	//TODO: Rework this class with the new Visitors
+
 	@Test
 	public void testAccept() {
 		BridgeObject bo = new BridgeObject(mock(AbstractBridge.class));
@@ -80,19 +85,13 @@ public class BridgeObjectTest {
 	@Test
 	public void testPrepareForChecking() {
 		BridgeObject bo = new BridgeObject(mock(AbstractBridge.class));
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-		bo.addBoundarySurface(bsMock);
+		Geometry geom = new Geometry(GeometryType.MULTI_SURFACE, Lod.LOD2);
+		Geometry spyGeom = Mockito.spy(geom);
+
+		bo.addGeometry(spyGeom);
 		bo.prepareForChecking();
-		verify(bsMock).prepareForChecking();
-	}
 
-	@Test
-	public void testClearMetaInformation() {
-		BridgeObject bo = new BridgeObject(mock(AbstractBridge.class));
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-		bo.addBoundarySurface(bsMock);
-		bo.clearMetaInformation();
-		verify(bsMock).clearMetaInformation();
+		verify(spyGeom).updateEdgesAndVertices();
 	}
 
 	@Test
@@ -106,10 +105,10 @@ public class BridgeObjectTest {
 	@Test
 	public void testContainsError2() {
 		BridgeObject bo = new BridgeObject(mock(AbstractBridge.class));
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-		bo.addBoundarySurface(bsMock);
+		BoundarySurface bs = new BoundarySurface(mock(AbstractThematicSurface.class));
+		bo.addBoundarySurface(bs);
 		assertFalse(bo.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
-		when(bsMock.containsError(CheckId.C_GE_P_HOLE_OUTSIDE)).thenReturn(true);
+		bs.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
 		assertTrue(bo.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
 	}
 
@@ -125,12 +124,13 @@ public class BridgeObjectTest {
 	@Test
 	public void testContainsAnyError() {
 		BridgeObject bo = new BridgeObject(mock(AbstractBridge.class));
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-		bo.addBoundarySurface(bsMock);
+		BoundarySurface bs = new BoundarySurface(mock(AbstractThematicSurface.class));
+		BoundarySurface spyBs = Mockito.spy(bs);
+		bo.addBoundarySurface(spyBs);
 		bo.containsAnyError();
-		verify(bsMock).containsAnyError();
-		
-		when(bsMock.containsAnyError()).thenReturn(true);
+		verify(spyBs).hasAnyError();
+
+		bs.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
 		assertTrue(bo.containsAnyError());
 		
 		BridgeObject bo2 = new BridgeObject(mock(AbstractBridge.class));
@@ -141,11 +141,13 @@ public class BridgeObjectTest {
 	@Test
 	public void testCollectContainedErrors() {
 		BridgeObject bo = new BridgeObject(mock(AbstractBridge.class));
-		BoundarySurface bsMock = mock(BoundarySurface.class);
-		bo.addBoundarySurface(bsMock);
+		BoundarySurface bs = new BoundarySurface(mock(AbstractThematicSurface.class));
+		BoundarySurface spyBs = Mockito.spy(bs);
+		bo.addBoundarySurface(spyBs);
+
 		ArrayList<CheckError> errors = new ArrayList<>();
 		bo.collectContainedErrors(errors);
-		verify(bsMock).collectContainedErrors(errors);
+		verify(spyBs).collectErrors(errors);
 	}
 
 	@Test
@@ -156,7 +158,7 @@ public class BridgeObjectTest {
 		GeometryFactory factoryMock = mock(GeometryFactory.class);
 		ParserConfiguration configMock = mock(ParserConfiguration.class);
 		bo.reCreateGeometries(factoryMock, configMock);
-		verify(bsMock).reCreateGeometries(factoryMock, configMock);
+		verify(bsMock).accept(any(GmlGeometryRebuilder.class));
 	}
 	
 	@Test

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

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class CityFurnitureTest {
+
+    //TODO: Implement testcases
+
+    @Test
+    public void accept() {
+    }
+
+    @Test
+    public void unsetGmlGeometries() {
+    }
+
+    @Test
+    public void getTopLevelCityObject() {
+    }
+
+    @Test
+    public void reCreateGeometries() {
+    }
+}
\ No newline at end of file

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

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import org.citygml4j.core.model.core.AbstractCityObject;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+public class CityObjectTest {
+
+    //TODO: Look for rework potential with visitors
+
+    CityObject co;
+
+    @Test
+    public void testVisitorPropagation() {
+        Geometry mockGeometry = mock(Geometry.class);
+        co.addGeometry(mockGeometry);
+
+        AbstractCheck check = new AbstractCheck() {
+        };
+
+        co.accept(check);
+
+        verify(mockGeometry).accept(check);
+    }
+
+
+    @Test
+    public void testClearGmlGeometries() {
+    }
+
+
+    @Test
+    public void testGetHighestLodGeometry() {
+        Geometry geometryLod1 = new Geometry(GeometryType.SOLID, Lod.LOD1);
+        Geometry geometryLod2 = new Geometry(GeometryType.SOLID, Lod.LOD2);
+        Geometry geometryLod3 = new Geometry(GeometryType.SOLID, Lod.LOD3);
+
+        assertNull(co.getHighestLodGeometry());
+
+        co.addGeometry(geometryLod1);
+        assertEquals(geometryLod1, co.getHighestLodGeometry());
+
+        co.addGeometry(geometryLod2);
+        assertEquals(geometryLod2, co.getHighestLodGeometry());
+
+        co.addGeometry(geometryLod3);
+
+        assertEquals(geometryLod3, co.getHighestLodGeometry());
+    }
+
+    @Before
+    public void setUp() {
+        co = new CityObject() {
+            @Override
+            public void rebuildGeometries(GeometryFactory factory, ParserConfiguration config) {
+
+            }
+
+            @Override
+            public AbstractCityObject getGmlObject() {
+                return null;
+            }
+
+            @Override
+            public void unsetGmlGeometries() {
+
+            }
+
+            @Override
+            public CityObject getTopLevelCityObject() {
+                return null;
+            }
+
+            @Override
+            public FeatureType getFeatureType() {
+                return null;
+            }
+
+            @Override
+            public Copyable createCopyInstance() {
+                return null;
+            }
+        };
+    }
+}
\ No newline at end of file

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

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
+import org.citygml4j.core.model.generics.GenericOccupiedSpace;
+import org.junit.Test;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
+import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+public class GenericCityObjectTest {
+
+    //TODO: Implement RecreateGeometries testcase
+
+    @Test
+    public void testVisitorPropagation() {
+        GenericCityObject gco = new GenericCityObject();
+        BoundarySurface mockSurface = mock(BoundarySurface.class);
+        Geometry mockGeometry = mock(Geometry.class);
+
+        gco.addBoundarySurface(mockSurface);
+        gco.addGeometry(mockGeometry);
+
+        AbstractCheck c = new AbstractCheck() {
+        };
+        gco.accept(c);
+
+        verify(mockSurface).accept(c);
+        verify(mockGeometry).accept(c);
+
+    }
+
+    @Test
+    public void testUnsetGmlGeometries() {
+        GenericCityObject gco = new GenericCityObject();
+        GenericOccupiedSpace gmlGos = new GenericOccupiedSpace();
+        gco.setGmlObject(gmlGos);
+
+        gmlGos.setLod0MultiSurface(new MultiSurfaceProperty());
+        gmlGos.setLod2MultiSurface(new MultiSurfaceProperty());
+        gmlGos.setLod3MultiSurface(new MultiSurfaceProperty());
+        gmlGos.setLod1Solid(new SolidProperty());
+        gmlGos.setLod2Solid(new SolidProperty());
+        gmlGos.setLod3Solid(new SolidProperty());
+        gmlGos.getDeprecatedProperties().setLod1Geometry(new MultiSurfaceProperty());
+        gmlGos.getDeprecatedProperties().setLod2Geometry(new MultiSurfaceProperty());
+        gmlGos.getDeprecatedProperties().setLod3Geometry(new MultiSurfaceProperty());
+        gmlGos.getDeprecatedProperties().setLod4Geometry(new MultiSurfaceProperty());
+
+        gco.unsetGmlGeometries();
+
+        assertNull(gmlGos.getLod0MultiSurface());
+        assertNull(gmlGos.getLod2MultiSurface());
+        assertNull(gmlGos.getLod3MultiSurface());
+        assertNull(gmlGos.getLod1Solid());
+        assertNull(gmlGos.getLod2Solid());
+        assertNull(gmlGos.getLod3Solid());
+        assertNull(gmlGos.getDeprecatedProperties().getLod1Geometry());
+        assertNull(gmlGos.getDeprecatedProperties().getLod2Geometry());
+        assertNull(gmlGos.getDeprecatedProperties().getLod3Geometry());
+        assertNull(gmlGos.getDeprecatedProperties().getLod4Geometry());
+    }
+
+    @Test
+    public void testReCreateGmlGeometries() {
+        GenericCityObject gco = new GenericCityObject();
+    }
+
+}
\ No newline at end of file

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

@@ -44,6 +44,7 @@ import de.hft.stuttgart.citydoctor2.check.ResultStatus;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
 import de.hft.stuttgart.citydoctor2.math.Vector3d;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import org.mockito.Mockito;
 
 /**
  * 
@@ -292,11 +293,15 @@ public class GeometryTest {
 		assertFalse(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
 		geom.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
 		assertTrue(geom.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
-		Polygon p = mock(Polygon.class);
-		geom.addPolygon(p);
+
+		Polygon p = new ConcretePolygon();
+		p.setExteriorRing(mock(LinearRing.class));
+		Polygon spyPoly = Mockito.spy(p);
+		geom.addPolygon(spyPoly);
+
 		List<CheckError> errors = new ArrayList<>();
 		geom.collectContainedErrors(errors);
-		verify(p).collectContainedErrors(errors);
+		verify(spyPoly).collectErrors(errors);
 		assertEquals(1, errors.size());
 	}
 
@@ -306,12 +311,16 @@ public class GeometryTest {
 		assertFalse(geom.containsAnyError());
 		geom.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
 		assertTrue(geom.containsAnyError());
-		Polygon p = mock(Polygon.class);
-		geom.addPolygon(p);
+
+		Polygon p = new ConcretePolygon();
+		p.setExteriorRing(mock(LinearRing.class));
+		Polygon spyPoly = Mockito.spy(p);
+		geom.addPolygon(spyPoly);
+
 		geom.clearAllContainedCheckResults();
 		assertFalse(geom.containsAnyError());
-		verify(p).containsAnyError();
-		when(p.containsAnyError()).thenReturn(true);
+		verify(spyPoly).hasAnyError();
+		spyPoly.addCheckResult((new CheckResult(CheckId.C_GE_R_NOT_CLOSED, ResultStatus.ERROR, mock(CheckError.class))));
 		assertTrue(geom.containsAnyError());
 	}