Test: Update Test cases for Visitor implementation

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

@@ -35,10 +35,10 @@ import de.hft.stuttgart.citydoctor2.utils.visitors.ClearCheckResultsVisitor;
 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.citygml4j.core.visitor.ObjectVisitor;
 import org.junit.Test;
 
 import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
@@ -161,120 +161,62 @@ public class BridgeObjectTest {
 		bo.reCreateGeometries(factoryMock, configMock);
 		verify(bsMock).accept(any(GmlGeometryRebuilder.class));
 	}
-	
-	@Test
-	public void testReCreateGeometriesMultiSurfaceLod1() {
-		BridgeObject bo = new BridgeObject(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());
 
-	}
-	
-	@Test
-	public void testReCreateGeometriesMultiSurfaceLod2() {
-		BridgeObject bo = new BridgeObject(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(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(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(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(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(mock(AbstractBridge.class));
-		Geometry geom = GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3);
-		AbstractBridge ab = new Bridge();
-		bo.setGmlObject(ab);
-		bo.addGeometry(geom);
+	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));
+
 		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(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);

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

@@ -161,8 +161,6 @@ public class BuildingTest {
 		verify(mockBuildingRoomFurniture, times(2)).accept(c);
 		verify(mockBuildingUnit, times(2)).accept(c);
 		verify(mockStorey, times(2)).accept(c);
-
-
 	}
 
 }

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

 package de.hft.stuttgart.citydoctor2.datastructure;
 
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import org.citygml4j.core.util.geometry.GeometryFactory;
 import org.junit.Test;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
 
 import static org.junit.Assert.*;
 
 public class CityFurnitureTest {
 
-    //TODO: Implement testcases
-
-    @Test
-    public void accept() {
-    }
 
     @Test
     public void unsetGmlGeometries() {
+        CityFurniture cf = new CityFurniture();
+        org.citygml4j.core.model.cityfurniture.CityFurniture cgmlCF = new org.citygml4j.core.model.cityfurniture.CityFurniture();
+        cf.setGmlObject(cgmlCF);
+
+        cgmlCF.setLod0MultiSurface(new MultiSurfaceProperty());
+        cgmlCF.setLod2MultiSurface(new MultiSurfaceProperty());
+        cgmlCF.setLod3MultiSurface(new MultiSurfaceProperty());
+        cgmlCF.setLod1Solid(null);
+        cgmlCF.setLod2Solid(null);
+        cgmlCF.setLod3Solid(null);
+        cgmlCF.getDeprecatedProperties().setLod1Geometry(null);
+        cgmlCF.getDeprecatedProperties().setLod2Geometry(null);
+        cgmlCF.getDeprecatedProperties().setLod3Geometry(null);
+        cgmlCF.getDeprecatedProperties().setLod4Geometry(null);
+
+        cf.clearGmlGeometries();
+
+        assertNull(cgmlCF.getLod0MultiSurface());
+        assertNull(cgmlCF.getLod2MultiSurface());
+        assertNull(cgmlCF.getLod3MultiSurface());
+        assertNull(cgmlCF.getLod1Solid());
+        assertNull(cgmlCF.getLod2Solid());
+        assertNull(cgmlCF.getLod3Solid());
+        assertNull(cgmlCF.getDeprecatedProperties().getLod1Geometry());
+        assertNull(cgmlCF.getDeprecatedProperties().getLod2Geometry());
+        assertNull(cgmlCF.getDeprecatedProperties().getLod3Geometry());
+        assertNull(cgmlCF.getDeprecatedProperties().getLod4Geometry());
+
     }
 
     @Test
-    public void getTopLevelCityObject() {
+    public void testReCreateGeometriesSolid() {
+        CityFurniture cf = new CityFurniture();
+        org.citygml4j.core.model.cityfurniture.CityFurniture cgmlCF = new org.citygml4j.core.model.cityfurniture.CityFurniture();
+        cf.setGmlObject(cgmlCF);
+        cf.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
+        cf.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
+        cf.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        cf.reCreateGeometries(factory, config);
+        GeometryTestUtils.assertSolidMatchesExpectedValues(cgmlCF.getLod1Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(cgmlCF.getLod2Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(cgmlCF.getLod3Solid().getObject());
     }
 
+
     @Test
-    public void reCreateGeometries() {
+    public void testReCreateGeometriesMultiSurface() {
+        CityFurniture cf = new CityFurniture();
+        org.citygml4j.core.model.cityfurniture.CityFurniture cgmlCF = new org.citygml4j.core.model.cityfurniture.CityFurniture();
+        cf.setGmlObject(cgmlCF);
+        cf.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
+        cf.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
+        cf.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+        cf.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+        cf.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        cf.reCreateGeometries(factory, config);
+
+        assertNotNull(cgmlCF.getLod0MultiSurface());
+        assertNotNull(cgmlCF.getLod0MultiSurface().getObject());
+        assertNotNull(cgmlCF.getLod2MultiSurface());
+        assertNotNull(cgmlCF.getLod2MultiSurface().getObject());
+        assertNotNull(cgmlCF.getLod3MultiSurface());
+        assertNotNull(cgmlCF.getLod3MultiSurface().getObject());
     }
 }
\ No newline at end of file

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

@@ -2,19 +2,21 @@ 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.visitors.GmlGeometryRebuilder;
+import de.hft.stuttgart.citydoctor2.utils.visitors.UnsetGeometriesVisitor;
 import org.citygml4j.core.model.core.AbstractCityObject;
 import org.citygml4j.core.util.geometry.GeometryFactory;
 import org.junit.Before;
 import org.junit.Test;
+import org.mockito.Mockito;
 
 import static org.junit.Assert.*;
+import static org.mockito.ArgumentMatchers.any;
 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
@@ -33,26 +35,63 @@ public class CityObjectTest {
 
     @Test
     public void testClearGmlGeometries() {
+        CityObject spyCo = Mockito.spy(co);
+        spyCo.clearGmlGeometries();
+
+        verify(spyCo).accept(any(UnsetGeometriesVisitor.class));
+        verify(spyCo).unsetGmlGeometries();
     }
 
 
+    @Test
+    public void testReCreateGmlGeometries() {
+        CityObject spyCo = Mockito.spy(co);
+        spyCo.reCreateGeometries(mock(GeometryFactory.class), mock(ParserConfiguration.class));
+
+        verify(spyCo).accept(any(GmlGeometryRebuilder.class));
+        verify(spyCo).rebuildGeometries(any(GeometryFactory.class), any(ParserConfiguration.class));
+    }
+
     @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);
+        Geometry geometryLod4 = new Geometry(GeometryType.SOLID, Lod.LOD4);
 
         assertNull(co.getHighestLodGeometry());
-
         co.addGeometry(geometryLod1);
         assertEquals(geometryLod1, co.getHighestLodGeometry());
-
         co.addGeometry(geometryLod2);
         assertEquals(geometryLod2, co.getHighestLodGeometry());
-
         co.addGeometry(geometryLod3);
+        assertEquals(geometryLod3, co.getHighestLodGeometry());
+        co.addGeometry(geometryLod4);
+        assertEquals(geometryLod4, co.getHighestLodGeometry());
 
+        setUp();
+
+        assertNull(co.getHighestLodGeometry());
+        co.addGeometry(geometryLod2);
+        assertEquals(geometryLod2, co.getHighestLodGeometry());
+        co.addGeometry(geometryLod1);
+        assertEquals(geometryLod2, co.getHighestLodGeometry());
+        co.addGeometry(geometryLod3);
         assertEquals(geometryLod3, co.getHighestLodGeometry());
+        co.addGeometry(geometryLod4);
+        assertEquals(geometryLod4, co.getHighestLodGeometry());
+
+        setUp();
+
+        assertNull(co.getHighestLodGeometry());
+        co.addGeometry(geometryLod4);
+        assertEquals(geometryLod4, co.getHighestLodGeometry());
+        co.addGeometry(geometryLod1);
+        assertEquals(geometryLod4, co.getHighestLodGeometry());
+        co.addGeometry(geometryLod2);
+        assertEquals(geometryLod4, co.getHighestLodGeometry());
+        co.addGeometry(geometryLod3);
+        assertEquals(geometryLod4, co.getHighestLodGeometry());
     }
 
     @Before
@@ -60,7 +99,7 @@ public class CityObjectTest {
         co = new CityObject() {
             @Override
             public void rebuildGeometries(GeometryFactory factory, ParserConfiguration config) {
-
+                // Stub for testing
             }
 
             @Override
@@ -70,7 +109,7 @@ public class CityObjectTest {
 
             @Override
             public void unsetGmlGeometries() {
-
+                // Stub for testing
             }
 
             @Override

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 de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 import org.citygml4j.core.model.generics.GenericOccupiedSpace;
+import org.citygml4j.core.util.geometry.GeometryFactory;
 import org.junit.Test;
 import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
 import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
@@ -12,8 +14,6 @@ import static org.mockito.Mockito.verify;
 
 public class GenericCityObjectTest {
 
-    //TODO: Implement RecreateGeometries testcase
-
     @Test
     public void testVisitorPropagation() {
         GenericCityObject gco = new GenericCityObject();
@@ -64,8 +64,44 @@ public class GenericCityObjectTest {
     }
 
     @Test
-    public void testReCreateGmlGeometries() {
+    public void testReCreateGeometriesSolid() {
+        GenericCityObject gco = new GenericCityObject();
+        GenericOccupiedSpace gmlGos = new GenericOccupiedSpace();
+        gco.setGmlObject(gmlGos);
+        gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
+        gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
+        gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
+        gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD4));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        gco.reCreateGeometries(factory, config);
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlGos.getLod1Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlGos.getLod2Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlGos.getLod3Solid().getObject());
+    }
+
+    @Test
+    public void testReCreateGeometriesMultiSurface() {
         GenericCityObject gco = new GenericCityObject();
+        GenericOccupiedSpace gmlGos = new GenericOccupiedSpace();
+        gco.setGmlObject(gmlGos);
+        gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
+        gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
+        gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+        gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+        gco.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        gco.reCreateGeometries(factory, config);
+
+        assertNotNull(gmlGos.getLod0MultiSurface());
+        assertNotNull(gmlGos.getLod0MultiSurface().getObject());
+        assertNotNull(gmlGos.getLod2MultiSurface());
+        assertNotNull(gmlGos.getLod2MultiSurface().getObject());
+        assertNotNull(gmlGos.getLod3MultiSurface());
+        assertNotNull(gmlGos.getLod3MultiSurface().getObject());
     }
 
 }
\ No newline at end of file

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

@@ -19,6 +19,17 @@
 package de.hft.stuttgart.citydoctor2.datastructure;
 
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
+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.SurfaceProperty;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 public class GeometryTestUtils {
 
@@ -97,4 +108,22 @@ public class GeometryTestUtils {
 		return geom;
 	}
 
+	public static void assertSolidMatchesExpectedValues(AbstractSolid aSolid) {
+		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 = getExpectedValues();
+		for (int i = 0; i < posList.size(); i++) {
+			assertEquals(expectedValues[i], posList.get(i), 0.00000001);
+		}
+	}
+
 }

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

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import org.citygml4j.core.model.landuse.LandUse;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.junit.Test;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
+
+import static org.junit.Assert.*;
+
+public class LandUseTest {
+
+    @Test
+    public void testUnsetGeometries() {
+        LandUse lu = new LandUse();
+        LandObject land = new LandObject(lu);
+
+        lu.setLod0MultiSurface(new MultiSurfaceProperty());
+        lu.setLod1MultiSurface(new MultiSurfaceProperty());
+        lu.setLod2MultiSurface(new MultiSurfaceProperty());
+        lu.setLod3MultiSurface(new MultiSurfaceProperty());
+        lu.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty());
+
+        land.clearGmlGeometries();
+
+        assertNull(lu.getLod0MultiSurface());
+        assertNull(lu.getLod1MultiSurface());
+        assertNull(lu.getLod2MultiSurface());
+        assertNull(lu.getLod3MultiSurface());
+        assertNull(lu.getDeprecatedProperties().getLod4MultiSurface());
+    }
+
+    @Test
+    public void testReCreateGeometries() {
+        LandUse lu = new LandUse();
+        LandObject land = new LandObject(lu);
+        land.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
+        land.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
+        land.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+        land.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+        land.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        land.reCreateGeometries(factory, config);
+
+        assertNotNull(lu.getLod0MultiSurface());
+        assertNotNull(lu.getLod0MultiSurface().getObject());
+        assertNotNull(lu.getLod1MultiSurface());
+        assertNotNull(lu.getLod1MultiSurface().getObject());
+        assertNotNull(lu.getLod2MultiSurface());
+        assertNotNull(lu.getLod2MultiSurface().getObject());
+        assertNotNull(lu.getLod3MultiSurface());
+        assertNotNull(lu.getLod3MultiSurface().getObject());
+        assertNotNull(lu.getDeprecatedProperties().getLod4MultiSurface());
+        assertNotNull(lu.getDeprecatedProperties().getLod4MultiSurface().getObject());
+    }
+
+
+}
\ No newline at end of file

CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/LandObjectTest.java → CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/ReliefObjectTest.java

 package de.hft.stuttgart.citydoctor2.datastructure;
 
 import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
-import org.citygml4j.core.model.landuse.LandUse;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 import org.citygml4j.core.model.relief.ReliefFeature;
 import org.citygml4j.core.model.relief.TINRelief;
 import org.citygml4j.core.model.relief.TinProperty;
+import org.citygml4j.core.util.geometry.GeometryFactory;
 import org.junit.Test;
-import org.xmlobjects.gml.model.geometry.aggregates.MultiCurveProperty;
-import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 
-public class LandObjectTest {
+public class ReliefObjectTest {
 
     @Test
     public void testVisitorPropagationReliefObject() {
@@ -42,25 +43,18 @@ public class LandObjectTest {
     }
 
     @Test
-    public void testUnsetGeometriesLandUse() {
-        LandUse lu = new LandUse();
-        LandObject land = new LandObject(lu);
+    public void testReCreateGeometriesTinObject() {
+        TINRelief tir = new TINRelief();
+        TinObject tin = new TinObject(tir);
 
-        lu.setLod0MultiCurve(new MultiCurveProperty());
-        lu.setLod0MultiSurface(new MultiSurfaceProperty());
-        lu.setLod1MultiSurface(new MultiSurfaceProperty());
-        lu.setLod2MultiSurface(new MultiSurfaceProperty());
-        lu.setLod3MultiSurface(new MultiSurfaceProperty());
-        lu.getDeprecatedProperties().setLod4MultiSurface(new MultiSurfaceProperty());
+        tin.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE));
 
-        land.clearGmlGeometries();
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        tin.reCreateGeometries(factory, config);
 
-        assertNull(lu.getLod0MultiCurve());
-        assertNull(lu.getLod0MultiSurface());
-        assertNull(lu.getLod1MultiSurface());
-        assertNull(lu.getLod2MultiSurface());
-        assertNull(lu.getLod3MultiSurface());
-        assertNull(lu.getDeprecatedProperties().getLod4MultiSurface());
+        assertNotNull(tir.getTin());
+        assertNotNull(tir.getTin().getObject());
+        assertEquals(2, tir.getLod());
     }
-
-}
+}
\ No newline at end of file

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

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+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.ResultStatus;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import org.citygml4j.core.model.deprecated.transportation.DeprecatedPropertiesOfAbstractTransportationSpace;
+import org.citygml4j.core.model.transportation.Railway;
+import org.citygml4j.core.model.transportation.Road;
+import org.citygml4j.core.model.transportation.Square;
+import org.citygml4j.core.model.transportation.Track;
+import org.citygml4j.core.model.transportation.Waterway;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
+
+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;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class TopLevelTransportFeatureTest {
+
+    @Test
+    public void testObjectConstruction() {
+        TopLevelTransportFeature road = TopLevelTransportFeature.from(Mockito.mock(Road.class));
+        assertEquals(TransportationObject.TransportationType.ROAD, road.getTransportationType());
+        TopLevelTransportFeature track = TopLevelTransportFeature.from(Mockito.mock(Track.class));
+        assertEquals(TransportationObject.TransportationType.TRACK, track.getTransportationType());
+        TopLevelTransportFeature waterway = TopLevelTransportFeature.from(Mockito.mock(Waterway.class));
+        assertEquals(TransportationObject.TransportationType.WATERWAY, waterway.getTransportationType());
+        TopLevelTransportFeature railway = TopLevelTransportFeature.from(Mockito.mock(Railway.class));
+        assertEquals(TransportationObject.TransportationType.RAILWAY, railway.getTransportationType());
+        TopLevelTransportFeature square = TopLevelTransportFeature.from(Mockito.mock(Square.class));
+        assertEquals(TransportationObject.TransportationType.SQUARE, square.getTransportationType());
+    }
+
+    @Test
+    public void testVisitorPropagationTopLevel() {
+        Road road = new Road();
+        TopLevelTransportFeature top = TopLevelTransportFeature.from(road);
+        TransportSection mockSection = mock(TransportSection.class);
+        TransportSection mockIntersection = mock(TransportSection.class);
+        top.addSection(mockSection);
+        top.addIntersection(mockIntersection);
+
+        AbstractCheck c = new AbstractCheck() {
+        };
+        top.accept(c);
+
+        verify(mockSection).accept(c);
+        verify(mockIntersection).accept(c);
+    }
+
+    @Test
+    public void testClearAllContainedCheckResults() {
+        Road roadMock = mock(Road.class);
+        TopLevelTransportFeature top = TopLevelTransportFeature.from(roadMock);
+
+        assertFalse(top.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        top.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
+        assertTrue(top.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        top.clearAllContainedCheckResults();
+        assertFalse(top.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+
+    }
+
+    @Test
+    public void testCollectContainedErrors() {
+        Road roadMock = mock(Road.class);
+        TopLevelTransportFeature top = TopLevelTransportFeature.from(roadMock);
+        top.setGmlObject(roadMock);
+
+        top.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
+        List<CheckError> errors = new ArrayList<>();
+        top.collectContainedErrors(errors);
+        assertEquals(1, errors.size());
+
+    }
+
+    @Test
+    public void testUnsetGmlGeometries() {
+        Road r = mock(Road.class);
+        TopLevelTransportFeature top = TopLevelTransportFeature.from(r);
+        top.setGmlObject(r);
+
+        DeprecatedPropertiesOfAbstractTransportationSpace dSpace = mock(DeprecatedPropertiesOfAbstractTransportationSpace.class);
+        when(r.getDeprecatedProperties()).thenReturn(dSpace);
+
+        dSpace.setLod1MultiSurface(mock(MultiSurfaceProperty.class));
+        r.setLod2MultiSurface(mock(MultiSurfaceProperty.class));
+        r.setLod3MultiSurface(mock(MultiSurfaceProperty.class));
+        dSpace.setLod4MultiSurface(mock(MultiSurfaceProperty.class));
+
+        top.unsetGmlGeometries();
+        assertNull(dSpace.getLod1MultiSurface());
+        assertNull(r.getLod2MultiSurface());
+        assertNull(r.getLod3MultiSurface());
+        assertNull(dSpace.getLod4MultiSurface());
+
+    }
+
+    @Test
+    public void testReCreateGeometriesSolid() {
+        Road gmlRoad = new Road();
+        TopLevelTransportFeature top = TopLevelTransportFeature.from(gmlRoad);
+        top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
+        top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
+        top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        top.reCreateGeometries(factory, config);
+
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlRoad.getLod1Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlRoad.getLod2Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlRoad.getLod3Solid().getObject());
+
+    }
+
+    @Test
+    public void testReCreateGeometriesMultiSurface() {
+        Road gmlRoad = new Road();
+        TopLevelTransportFeature top = TopLevelTransportFeature.from(gmlRoad);
+        top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
+        top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
+        top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+        top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+        top.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        top.reCreateGeometries(factory, config);
+
+        assertNotNull(gmlRoad.getLod0MultiSurface());
+        assertNotNull(gmlRoad.getLod0MultiSurface().getObject());
+        assertNotNull(gmlRoad.getDeprecatedProperties().getLod1MultiSurface());
+        assertNotNull(gmlRoad.getDeprecatedProperties().getLod1MultiSurface().getObject());
+        assertNotNull(gmlRoad.getLod2MultiSurface());
+        assertNotNull(gmlRoad.getLod2MultiSurface().getObject());
+        assertNotNull(gmlRoad.getLod3MultiSurface());
+        assertNotNull(gmlRoad.getLod3MultiSurface().getObject());
+        assertNotNull(gmlRoad.getDeprecatedProperties().getLod4MultiSurface());
+        assertNotNull(gmlRoad.getDeprecatedProperties().getLod4MultiSurface().getObject());
+    }
+}

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

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+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.deprecated.core.DeprecatedPropertiesOfAbstractThematicSurface;
+import org.citygml4j.core.model.transportation.TrafficArea;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.junit.Test;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
+
+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;
+import static org.mockito.Mockito.when;
+
+public class TrafficAreaTest {
+
+    @Test
+    public void testContainsError() {
+        TrafficAreaObject tao = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
+        TrafficArea taMock = mock(TrafficArea.class);
+        tao.setGmlObject(taMock);
+
+        tao.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
+        assertTrue(tao.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        assertFalse(tao.containsError(CheckId.C_GE_P_INNER_RINGS_NESTED));
+    }
+
+    @Test
+    public void testClearAllContainedCheckResults() {
+        TrafficAreaObject tao = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
+        TrafficArea taMock = mock(TrafficArea.class);
+        tao.setGmlObject(taMock);
+
+        assertFalse(tao.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        tao.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
+        assertTrue(tao.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        tao.clearAllContainedCheckResults();
+        assertFalse(tao.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+
+    }
+
+    @Test
+    public void testCollectContainedErrors() {
+        TrafficAreaObject tao = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
+        TrafficArea taMock = mock(TrafficArea.class);
+        tao.setGmlObject(taMock);
+
+        tao.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
+        List<CheckError> errors = new ArrayList<>();
+        tao.collectContainedErrors(errors);
+        assertEquals(1, errors.size());
+    }
+
+    @Test
+    public void testUnsetGmlGeometries() {
+        TrafficAreaObject ta = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
+        TrafficArea r = mock(TrafficArea.class);
+        ta.setGmlObject(r);
+        DeprecatedPropertiesOfAbstractThematicSurface dSpace = mock(DeprecatedPropertiesOfAbstractThematicSurface.class);
+        when(r.getDeprecatedProperties()).thenReturn(dSpace);
+
+        r.setLod0MultiSurface(mock(MultiSurfaceProperty.class));
+        r.setLod1MultiSurface(mock(MultiSurfaceProperty.class));
+        r.setLod2MultiSurface(mock(MultiSurfaceProperty.class));
+        r.setLod3MultiSurface(mock(MultiSurfaceProperty.class));
+        dSpace.setLod4MultiSurface(mock(MultiSurfaceProperty.class));
+
+        ta.unsetGmlGeometries();
+        assertNull(r.getLod0MultiSurface());
+        assertNull(r.getLod1MultiSurface());
+        assertNull(r.getLod2MultiSurface());
+        assertNull(r.getLod3MultiSurface());
+        assertNull(dSpace.getLod4MultiSurface());
+    }
+
+    @Test
+    public void testReCreateGeometriesMultiSurface() {
+        TrafficArea gmlAus = new TrafficArea() {
+        };
+        TrafficAreaObject tao = new TrafficAreaObject(TrafficAreaObject.TrafficAreaType.TRAFFIC_AREA);
+        tao.setGmlObject(gmlAus);
+
+        tao.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
+        tao.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
+        tao.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+        tao.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+        tao.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        tao.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/TrafficSpaceTest.java

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+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.ResultStatus;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import de.hft.stuttgart.citydoctor2.utils.visitors.ClearCheckResultsVisitor;
+import org.citygml4j.core.model.core.AbstractSpaceBoundary;
+import org.citygml4j.core.model.core.AbstractUnoccupiedSpace;
+import org.citygml4j.core.model.deprecated.core.DeprecatedPropertiesOfAbstractCityObject;
+import org.citygml4j.core.model.transportation.TrafficSpace;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.citygml4j.core.visitor.ObjectVisitor;
+import org.junit.Test;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
+
+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.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class TrafficSpaceTest {
+
+    @Test
+    public void testVisitorPropagation() {
+        TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
+        TrafficAreaObject areaMock = mock(TrafficAreaObject.class);
+        tso.addTrafficArea(areaMock);
+
+        AbstractCheck c = new AbstractCheck() {
+        };
+        tso.accept(c);
+
+        verify(areaMock).accept(c);
+    }
+
+    @Test
+    public void testContainsError() {
+        TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
+
+        tso.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
+        assertTrue(tso.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        assertFalse(tso.containsError(CheckId.C_GE_P_INNER_RINGS_NESTED));
+
+    }
+
+    @Test
+    public void testCollectContainedErrors() {
+        TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
+
+        tso.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
+        List<CheckError> errors = new ArrayList<>();
+        tso.collectContainedErrors(errors);
+        assertEquals(1, errors.size());
+
+    }
+
+    @Test
+    public void testClearAllContainedCheckResults() {
+        TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
+        TrafficSpace tsMock = mock(TrafficSpace.class);
+        tso.setGmlObject(tsMock);
+        TrafficAreaObject taMock = mock(TrafficAreaObject.class);
+
+        tso.addTrafficArea(taMock);
+
+        assertFalse(tso.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        tso.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
+        assertTrue(tso.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        tso.clearAllContainedCheckResults();
+        assertFalse(tso.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+
+        verify(taMock).accept(any(ClearCheckResultsVisitor.class));
+    }
+
+    @Test
+    public void testUnsetGmlGeometries() {
+        TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
+        TrafficSpace t = mock(TrafficSpace.class);
+        tso.setGmlObject(t);
+
+        DeprecatedPropertiesOfAbstractCityObject dSpace = mock(DeprecatedPropertiesOfAbstractCityObject.class);
+        when(t.getDeprecatedProperties()).thenReturn(dSpace);
+
+        t.setLod0MultiSurface(mock(MultiSurfaceProperty.class));
+        t.setLod2MultiSurface(mock(MultiSurfaceProperty.class));
+        t.setLod3MultiSurface(mock(MultiSurfaceProperty.class));
+
+        tso.unsetGmlGeometries();
+        assertNull(t.getLod0MultiSurface());
+        assertNull(t.getLod2MultiSurface());
+        assertNull(t.getLod3MultiSurface());
+
+    }
+
+    @Test
+    public void testReCreateGeometriesSolid() {
+        AbstractUnoccupiedSpace gmlAus = new AbstractUnoccupiedSpace() {
+            @Override
+            public boolean isValidBoundary(Class<? extends AbstractSpaceBoundary> type) {
+                return false;
+            }
+
+            @Override
+            public void accept(ObjectVisitor visitor) {
+
+            }
+        };
+        TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE) {
+        };
+        tso.setGmlObject(gmlAus);
+
+        tso.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
+        tso.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
+        tso.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        tso.reCreateGeometries(factory, config);
+
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAus.getLod1Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAus.getLod2Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAus.getLod3Solid().getObject());
+
+    }
+
+    @Test
+    public void testReCreateGeometriesMultiSurface() {
+        AbstractUnoccupiedSpace gmlAus = new AbstractUnoccupiedSpace() {
+            @Override
+            public boolean isValidBoundary(Class<? extends AbstractSpaceBoundary> type) {
+                return false;
+            }
+
+            @Override
+            public void accept(ObjectVisitor visitor) {
+
+            }
+        };
+        TrafficSpaceObject tso = new TrafficSpaceObject(TrafficSpaceObject.TrafficSpaceType.TRAFFIC_SPACE);
+        tso.setGmlObject(gmlAus);
+
+        tso.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
+        tso.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+        tso.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        tso.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/TransportationSpaceTest.java

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+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.ResultStatus;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import org.citygml4j.core.model.transportation.AbstractTransportationSpace;
+import org.citygml4j.core.model.transportation.Road;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.citygml4j.core.visitor.ObjectVisitor;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+public class TransportationSpaceTest {
+
+    @Test
+    public void testVisitorPropagation() {
+        TransportationSpace space = new TransportationSpace(TransportationObject.TransportationType.TRANSPORTATION_COMPLEX) {
+        };
+        TrafficSpaceObject mockSpace = mock(TrafficSpaceObject.class);
+        TrafficSpaceObject auxMockSpace = mock(TrafficSpaceObject.class);
+        space.addTrafficSpace(mockSpace);
+        space.addAuxTrafficSpace(auxMockSpace);
+
+        AbstractCheck c = new AbstractCheck() {
+        };
+        space.accept(c);
+
+        verify(mockSpace).accept(c);
+        verify(auxMockSpace).accept(c);
+    }
+
+
+    @Test
+    public void testReCreateGeometriesSolid() {
+        AbstractTransportationSpace gmlAts = new AbstractTransportationSpace() {
+            @Override
+            public void accept(ObjectVisitor visitor) {
+
+            }
+        };
+        TransportationSpace space = new TransportationSpace(TransportationObject.TransportationType.TRANSPORTATION_COMPLEX) {
+        };
+        space.setGmlObject(gmlAts);
+
+        space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
+        space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
+        space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        space.reCreateGeometries(factory, config);
+
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAts.getLod1Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAts.getLod2Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlAts.getLod3Solid().getObject());
+
+    }
+
+    @Test
+    public void testReCreateGeometriesMultiSurface() {
+        AbstractTransportationSpace gmlAts = new AbstractTransportationSpace() {
+            @Override
+            public void accept(ObjectVisitor visitor) {
+
+            }
+        };
+        TransportationSpace space = new TransportationSpace(TransportationObject.TransportationType.TRANSPORTATION_COMPLEX) {
+        };
+        space.setGmlObject(gmlAts);
+
+        space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
+        space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
+        space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+        space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+        space.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        space.reCreateGeometries(factory, config);
+
+        assertNotNull(gmlAts.getLod0MultiSurface());
+        assertNotNull(gmlAts.getLod0MultiSurface().getObject());
+        assertNotNull(gmlAts.getDeprecatedProperties().getLod1MultiSurface());
+        assertNotNull(gmlAts.getDeprecatedProperties().getLod1MultiSurface().getObject());
+        assertNotNull(gmlAts.getLod2MultiSurface());
+        assertNotNull(gmlAts.getLod2MultiSurface().getObject());
+        assertNotNull(gmlAts.getLod3MultiSurface());
+        assertNotNull(gmlAts.getLod3MultiSurface().getObject());
+        assertNotNull(gmlAts.getDeprecatedProperties().getLod4MultiSurface());
+        assertNotNull(gmlAts.getDeprecatedProperties().getLod4MultiSurface().getObject());
+    }
+
+    @Test
+    public void testContainsError() {
+        Road roadMock = mock(Road.class);
+        TopLevelTransportFeature top = TopLevelTransportFeature.from(roadMock);
+        top.setGmlObject(roadMock);
+
+        top.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, mock(CheckError.class)));
+        assertTrue(top.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+        assertFalse(top.containsError(CheckId.C_GE_P_INNER_RINGS_NESTED));
+    }
+}

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

 package de.hft.stuttgart.citydoctor2.datastructure;
 
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 import org.citygml4j.core.model.vegetation.PlantCover;
 import org.citygml4j.core.model.vegetation.SolitaryVegetationObject;
+import org.citygml4j.core.util.geometry.GeometryFactory;
 import org.junit.Test;
 import org.xmlobjects.gml.model.geometry.GeometryProperty;
-import org.xmlobjects.gml.model.geometry.aggregates.MultiCurveProperty;
 import org.xmlobjects.gml.model.geometry.aggregates.MultiSolidProperty;
 import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
 import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
 
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 
 public class VegetationTest {
@@ -21,9 +23,6 @@ public class VegetationTest {
         PlantCover gmlCover = new PlantCover();
         plantCover.setGmlObject(gmlCover);
 
-        gmlCover.setLod0MultiCurve(new MultiCurveProperty());
-        gmlCover.setLod2MultiCurve(new MultiCurveProperty());
-        gmlCover.setLod3MultiCurve(new MultiCurveProperty());
         gmlCover.setLod0MultiSurface(new MultiSurfaceProperty());
         gmlCover.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty());
         gmlCover.setLod2MultiSurface(new MultiSurfaceProperty());
@@ -39,9 +38,6 @@ public class VegetationTest {
 
         plantCover.clearGmlGeometries();
 
-        assertNull(gmlCover.getLod0MultiCurve());
-        assertNull(gmlCover.getLod2MultiCurve());
-        assertNull(gmlCover.getLod3MultiCurve());
         assertNull(gmlCover.getLod0MultiSurface());
         assertNull(gmlCover.getDeprecatedProperties().getLod1MultiSurface());
         assertNull(gmlCover.getLod2MultiSurface());
@@ -62,9 +58,6 @@ public class VegetationTest {
         SolitaryVegetationObject gmlSolitary = new SolitaryVegetationObject();
         solitary.setGmlObject(gmlSolitary);
 
-        gmlSolitary.setLod0MultiCurve(new MultiCurveProperty());
-        gmlSolitary.setLod2MultiCurve(new MultiCurveProperty());
-        gmlSolitary.setLod3MultiCurve(new MultiCurveProperty());
         gmlSolitary.setLod0MultiSurface(new MultiSurfaceProperty());
         gmlSolitary.setLod2MultiSurface(new MultiSurfaceProperty());
         gmlSolitary.setLod3MultiSurface(new MultiSurfaceProperty());
@@ -78,9 +71,6 @@ public class VegetationTest {
 
         solitary.clearGmlGeometries();
 
-        assertNull(gmlSolitary.getLod0MultiCurve());
-        assertNull(gmlSolitary.getLod2MultiCurve());
-        assertNull(gmlSolitary.getLod3MultiCurve());
         assertNull(gmlSolitary.getLod0MultiSurface());
         assertNull(gmlSolitary.getLod2MultiSurface());
         assertNull(gmlSolitary.getLod3MultiSurface());
@@ -92,4 +82,97 @@ public class VegetationTest {
         assertNull(gmlSolitary.getDeprecatedProperties().getLod3Geometry());
         assertNull(gmlSolitary.getDeprecatedProperties().getLod4Geometry());
     }
+
+    @Test
+    public void testReCreateGeometriesSolidPlantCover() {
+        PlantCover gmlPC = new PlantCover();
+        Vegetation veg = new Vegetation(Vegetation.VegetationType.PLANT_COVER);
+        veg.setGmlObject(gmlPC);
+
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        veg.reCreateGeometries(factory, config);
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlPC.getLod1Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlPC.getLod2Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlPC.getLod3Solid().getObject());
+    }
+
+    @Test
+    public void testReCreateGeometriesMultiSurfacePlantCover() {
+        PlantCover gmlPC = new PlantCover();
+        Vegetation veg = new Vegetation(Vegetation.VegetationType.PLANT_COVER);
+        veg.setGmlObject(gmlPC);
+
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        veg.reCreateGeometries(factory, config);
+
+        assertNotNull(gmlPC.getLod0MultiSurface());
+        assertNotNull(gmlPC.getLod0MultiSurface().getObject());
+        assertNotNull(gmlPC.getDeprecatedProperties().getLod1MultiSurface());
+        assertNotNull(gmlPC.getDeprecatedProperties().getLod1MultiSurface().getObject());
+        assertNotNull(gmlPC.getLod2MultiSurface());
+        assertNotNull(gmlPC.getLod2MultiSurface().getObject());
+        assertNotNull(gmlPC.getLod3MultiSurface());
+        assertNotNull(gmlPC.getLod3MultiSurface().getObject());
+        assertNotNull(gmlPC.getDeprecatedProperties().getLod4MultiSurface());
+        assertNotNull(gmlPC.getDeprecatedProperties().getLod4MultiSurface().getObject());
+    }
+
+    @Test
+    public void testReCreateGeometriesSolidSolitaryVegetationObject() {
+        SolitaryVegetationObject gmlPC = new SolitaryVegetationObject();
+        Vegetation veg = new Vegetation(Vegetation.VegetationType.SOLITARY_VEGETATION_OBJECT);
+        veg.setGmlObject(gmlPC);
+
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        veg.reCreateGeometries(factory, config);
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlPC.getLod1Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlPC.getLod2Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlPC.getLod3Solid().getObject());
+    }
+
+    @Test
+    public void testReCreateGeometriesMultiSurfaceSolitaryVegetationObject() {
+        SolitaryVegetationObject gmlPC = new SolitaryVegetationObject();
+        Vegetation veg = new Vegetation(Vegetation.VegetationType.SOLITARY_VEGETATION_OBJECT);
+        veg.setGmlObject(gmlPC);
+
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+        veg.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        veg.reCreateGeometries(factory, config);
+
+        assertNotNull(gmlPC.getLod0MultiSurface());
+        assertNotNull(gmlPC.getLod0MultiSurface().getObject());
+        assertNotNull(gmlPC.getDeprecatedProperties().getLod1Geometry());
+        assertNotNull(gmlPC.getDeprecatedProperties().getLod1Geometry().getObject());
+        assertNotNull(gmlPC.getLod2MultiSurface());
+        assertNotNull(gmlPC.getLod2MultiSurface().getObject());
+        assertNotNull(gmlPC.getLod3MultiSurface());
+        assertNotNull(gmlPC.getLod3MultiSurface().getObject());
+        assertNotNull(gmlPC.getDeprecatedProperties().getLod4Geometry());
+        assertNotNull(gmlPC.getDeprecatedProperties().getLod4Geometry().getObject());
+    }
+
 }

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

 package de.hft.stuttgart.citydoctor2.datastructure;
 
 import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 import org.citygml4j.core.model.waterbody.WaterBody;
+import org.citygml4j.core.util.geometry.GeometryFactory;
 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.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
@@ -35,10 +37,6 @@ public class WaterTest {
         WaterBody gmlWater = new WaterBody();
         water.setGmlObject(gmlWater);
 
-        gmlWater.setLod0MultiCurve(new MultiCurveProperty());
-        gmlWater.getDeprecatedProperties().setLod1MultiCurve(new MultiCurveProperty());
-        gmlWater.setLod2MultiCurve(new MultiCurveProperty());
-        gmlWater.setLod3MultiCurve(new MultiCurveProperty());
         gmlWater.setLod0MultiSurface(new MultiSurfaceProperty());
         gmlWater.getDeprecatedProperties().setLod1MultiSurface(new MultiSurfaceProperty());
         gmlWater.setLod2MultiSurface(new MultiSurfaceProperty());
@@ -50,10 +48,6 @@ public class WaterTest {
 
         water.clearGmlGeometries();
 
-        assertNull(gmlWater.getLod0MultiCurve());
-        assertNull(gmlWater.getDeprecatedProperties().getLod1MultiCurve());
-        assertNull(gmlWater.getLod2MultiCurve());
-        assertNull(gmlWater.getLod3MultiCurve());
         assertNull(gmlWater.getLod0MultiSurface());
         assertNull(gmlWater.getDeprecatedProperties().getLod1MultiSurface());
         assertNull(gmlWater.getLod2MultiSurface());
@@ -66,9 +60,48 @@ public class WaterTest {
 
 
     @Test
-    public void testRecreateGmlGeometries() {
+    public void testReCreateGeometriesSolid() {
+        WaterBody gmlWater = new WaterBody();
         WaterObject water = new WaterObject();
-        // TODO: Implement test
+
+        water.setGmlObject(gmlWater);
+        water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD1));
+        water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD2));
+        water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD3));
+        water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID, Lod.LOD4));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        water.reCreateGeometries(factory, config);
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlWater.getLod1Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlWater.getLod2Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlWater.getLod3Solid().getObject());
+        GeometryTestUtils.assertSolidMatchesExpectedValues(gmlWater.getDeprecatedProperties().getLod4Solid().getObject());
+    }
+
+    @Test
+    public void testReCreateGeometriesMultiSurface() {
+        WaterBody gmlWater = new WaterBody();
+        WaterObject water = new WaterObject();
+
+        water.setGmlObject(gmlWater);
+        water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD0));
+        water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
+        water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD2));
+        water.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+
+        GeometryFactory factory = GeometryFactory.newInstance();
+        ParserConfiguration config = new ParserConfiguration(8, false);
+        water.reCreateGeometries(factory, config);
+
+        assertNotNull(gmlWater.getLod0MultiSurface());
+        assertNotNull(gmlWater.getLod0MultiSurface().getObject());
+        assertNotNull(gmlWater.getDeprecatedProperties().getLod1MultiSurface());
+        assertNotNull(gmlWater.getDeprecatedProperties().getLod1MultiSurface().getObject());
+        assertNotNull(gmlWater.getLod2MultiSurface());
+        assertNotNull(gmlWater.getLod2MultiSurface().getObject());
+        assertNotNull(gmlWater.getLod3MultiSurface());
+        assertNotNull(gmlWater.getLod3MultiSurface().getObject());
     }
 
 }