diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingTest.java
index e3d2e084ec7240033122e6652feff7bc93588ce6..e8dd88b4efdcbf936b3846cf0afba2a2b07fa6f1 100644
--- a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingTest.java
+++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/AbstractBuildingTest.java
@@ -52,7 +52,6 @@ import de.hft.stuttgart.citydoctor2.check.CheckResult;
import de.hft.stuttgart.citydoctor2.check.Requirement;
import de.hft.stuttgart.citydoctor2.check.RequirementType;
import de.hft.stuttgart.citydoctor2.check.ResultStatus;
-import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
public class AbstractBuildingTest {
@@ -278,7 +277,7 @@ public class AbstractBuildingTest {
@Test
public void testReCreateGeometriesSolid() {
- Geometry geom = createDummyGeometry(GeometryType.SOLID);
+ Geometry geom = GeometryTestUtils.createDummyGeometry(GeometryType.SOLID);
AbstractBuilding ab = new AbstractBuilding() {
private static final long serialVersionUID = -448362592456318541L;
@@ -317,7 +316,7 @@ public class AbstractBuildingTest {
@Test
public void testReCreateGeometriesMultiSurface() {
- Geometry geom = createDummyGeometry(GeometryType.MULTI_SURFACE);
+ Geometry geom = GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE);
AbstractBuilding ab = new AbstractBuilding() {
private static final long serialVersionUID = -448362592456318541L;
@@ -332,26 +331,6 @@ public class AbstractBuildingTest {
assertNotNull(gmlAb.getLod2MultiSurface().getGeometry());
}
- private Geometry createDummyGeometry(GeometryType type) {
- Geometry geom = new Geometry(type, Lod.LOD2);
- ConcretePolygon polygon = new ConcretePolygon();
- geom.getPolygons().add(polygon);
- polygon.setParent(geom);
- LinearRing lr = new LinearRing(LinearRingType.EXTERIOR);
- polygon.setExteriorRing(lr);
- Vertex v1 = new Vertex(427583.301, 6003502.571, 9.711);
- lr.getVertices().add(v1);
- Vertex v2 = new Vertex(427583.304, 6003502.574, 9.713);
- lr.getVertices().add(v2);
- Vertex v3 = new Vertex(427583.304, 6003502.574, 4.097);
- lr.getVertices().add(v3);
- Vertex v4 = new Vertex(427583.301, 6003502.571, 4.097);
- lr.getVertices().add(v4);
- lr.getVertices().add(v1);
- geom.updateEdgesAndVertices();
- return geom;
- }
-
@Test
public void testReCreateGeometriesBs() {
BoundarySurface bsMock = Mockito.mock(BoundarySurface.class);
@@ -359,7 +338,7 @@ public class AbstractBuildingTest {
private static final long serialVersionUID = -448362592456318541L;
};
List<Geometry> geometries = new ArrayList<>();
- geometries.add(createDummyGeometry(GeometryType.MULTI_SURFACE));
+ geometries.add(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE));
Mockito.when(bsMock.getGeometries()).thenReturn(geometries);
ab.addBoundarySurface(bsMock);
org.citygml4j.model.citygml.building.AbstractBuilding gmlAb = new org.citygml4j.model.citygml.building.Building();
diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BoundarySurfaceTest.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BoundarySurfaceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b86dd653115a68c04fa29a13bc950bcf9d354217
--- /dev/null
+++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/BoundarySurfaceTest.java
@@ -0,0 +1,481 @@
+/*-
+ * Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
+ *
+ * This file is part of CityDoctor2.
+ *
+ * CityDoctor2 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * CityDoctor2 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with CityDoctor2. If not, see <https://www.gnu.org/licenses/>.
+ */
+package de.hft.stuttgart.citydoctor2.datastructure;
+
+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 java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.citygml4j.factory.GMLGeometryFactory;
+import org.citygml4j.model.citygml.building.WallSurface;
+import org.citygml4j.model.citygml.core.AbstractCityObject;
+import org.citygml4j.model.gml.geometry.aggregates.MultiSurfaceProperty;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import de.hft.stuttgart.citydoctor2.check.Check;
+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.Requirement;
+import de.hft.stuttgart.citydoctor2.check.RequirementType;
+import de.hft.stuttgart.citydoctor2.check.ResultStatus;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+
+public class BoundarySurfaceTest {
+
+ @Test
+ public void testAccept() {
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
+ Opening oMock = Mockito.mock(Opening.class);
+ bs.addOpening(oMock);
+ AtomicInteger bsCounter = new AtomicInteger(0);
+ Check c = new Check() {
+
+ @Override
+ public Set<Requirement> appliesToRequirements() {
+ return null;
+ }
+
+ @Override
+ public CheckId getCheckId() {
+ return null;
+ }
+
+ @Override
+ public RequirementType getType() {
+ return null;
+ }
+
+ @Override
+ public Check createNewInstance() {
+ return null;
+ }
+
+ @Override
+ public void check(BoundarySurface bs) {
+ bsCounter.incrementAndGet();
+ }
+ };
+ bs.accept(c);
+ Mockito.verify(oMock).accept(c);
+ assertEquals(1, bsCounter.intValue());
+ }
+
+ @Test
+ public void testAcceptWithoutFittingCheck() {
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
+ Opening oMock = Mockito.mock(Opening.class);
+ bs.addOpening(oMock);
+ AtomicInteger bsCounter = new AtomicInteger(0);
+ Check c = new Check() {
+
+ @Override
+ public Set<Requirement> appliesToRequirements() {
+ return null;
+ }
+
+ @Override
+ public CheckId getCheckId() {
+ return null;
+ }
+
+ @Override
+ public RequirementType getType() {
+ return null;
+ }
+
+ @Override
+ public Check createNewInstance() {
+ return null;
+ }
+
+ @Override
+ public void check(BridgeObject bo) {
+ bsCounter.incrementAndGet();
+ }
+ };
+ bs.accept(c);
+ Mockito.verify(oMock).accept(c);
+ assertEquals(0, bsCounter.intValue());
+ }
+
+ @Test
+ public void testPrepareForChecking() {
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
+ Opening oMock = Mockito.mock(Opening.class);
+ bs.addOpening(oMock);
+ 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();
+ }
+
+ @Test
+ public void testContainsError() {
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
+ assertFalse(bs.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+ bs.addCheckResult(
+ new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, Mockito.mock(CheckError.class)));
+ assertTrue(bs.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+ assertFalse(bs.containsError(CheckId.C_GE_P_INNER_RINGS_NESTED));
+ }
+
+ @Test
+ public void testContainsErrorInOpening() {
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
+ assertFalse(bs.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+ Opening o = new Opening(OpeningType.WINDOW, SurfaceFeatureType.BUILDING, bs, null);
+ bs.addOpening(o);
+ o.addCheckResult(
+ new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, Mockito.mock(CheckError.class)));
+ assertTrue(bs.containsError(CheckId.C_GE_P_HOLE_OUTSIDE));
+ assertFalse(bs.containsError(CheckId.C_GE_P_INNER_RINGS_NESTED));
+ }
+
+ @Test
+ public void testClearAllContainedCheckResults() {
+ 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)));
+ assertFalse(bs.getAllCheckResults().isEmpty());
+ bs.addOpening(oMock);
+ bs.clearAllContainedCheckResults();
+ Mockito.verify(oMock).clearAllContainedCheckResults();
+ assertTrue(bs.getAllCheckResults().isEmpty());
+ }
+
+ @Test
+ public void testContainsAnyError() {
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, null);
+ Opening oMock = Mockito.mock(Opening.class);
+ bs.addOpening(oMock);
+ 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
+ public void testReCreateGeometriesWithoutId() {
+ WallSurface ws = new WallSurface();
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+ bs.reCreateGeometries(new GMLGeometryFactory(), new ParserConfiguration(8, false));
+ assertNotNull(ws.getId());
+ }
+
+ @Test
+ public void testReCreateGeometriesWithId() {
+ WallSurface ws = new WallSurface();
+ ws.setId("test");
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+ bs.reCreateGeometries(new GMLGeometryFactory(), new ParserConfiguration(8, false));
+ // nothing has changed
+ assertEquals("test", ws.getId());
+ assertNull(ws.getLod2MultiSurface());
+ assertNull(ws.getLod3MultiSurface());
+ assertNull(ws.getLod4MultiSurface());
+ }
+
+ @Test
+ public void testReCreateGeometriesMultiSurfaceLod2() {
+ WallSurface ws = new WallSurface();
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+ bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE));
+ bs.reCreateGeometries(new GMLGeometryFactory(), new ParserConfiguration(8, false));
+ assertNotNull(ws.getLod2MultiSurface());
+ assertNull(ws.getLod3MultiSurface());
+ assertNull(ws.getLod4MultiSurface());
+ }
+
+ @Test
+ public void testReCreateGeometriesMultiSurfaceBridgeLod2() {
+ org.citygml4j.model.citygml.bridge.WallSurface ws = new org.citygml4j.model.citygml.bridge.WallSurface();
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BRIDGE, BoundarySurfaceType.WALL, ws);
+ bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE));
+ bs.reCreateGeometries(new GMLGeometryFactory(), new ParserConfiguration(8, false));
+ assertNotNull(ws.getLod2MultiSurface());
+ assertNull(ws.getLod3MultiSurface());
+ assertNull(ws.getLod4MultiSurface());
+ }
+
+ @Test
+ public void testReCreateGeometriesMultiSurfaceBridgeLod3() {
+ org.citygml4j.model.citygml.bridge.WallSurface ws = new org.citygml4j.model.citygml.bridge.WallSurface();
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BRIDGE, BoundarySurfaceType.WALL, ws);
+ bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+ bs.reCreateGeometries(new GMLGeometryFactory(), new ParserConfiguration(8, false));
+ assertNull(ws.getLod2MultiSurface());
+ assertNotNull(ws.getLod3MultiSurface());
+ assertNull(ws.getLod4MultiSurface());
+ }
+
+ @Test
+ public void testReCreateGeometriesMultiSurfaceBridgeLod4() {
+ org.citygml4j.model.citygml.bridge.WallSurface ws = new org.citygml4j.model.citygml.bridge.WallSurface();
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BRIDGE, BoundarySurfaceType.WALL, ws);
+ bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+ bs.reCreateGeometries(new GMLGeometryFactory(), new ParserConfiguration(8, false));
+ assertNull(ws.getLod2MultiSurface());
+ assertNull(ws.getLod3MultiSurface());
+ assertNotNull(ws.getLod4MultiSurface());
+ }
+
+ @Test
+ public void testReCreateGeometriesMultiSurfaceTunnelLod2() {
+ org.citygml4j.model.citygml.tunnel.WallSurface ws = new org.citygml4j.model.citygml.tunnel.WallSurface();
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, ws);
+ bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE));
+ bs.reCreateGeometries(new GMLGeometryFactory(), new ParserConfiguration(8, false));
+ assertNotNull(ws.getLod2MultiSurface());
+ assertNull(ws.getLod3MultiSurface());
+ assertNull(ws.getLod4MultiSurface());
+ }
+
+ @Test
+ public void testReCreateGeometriesMultiSurfaceTunnelLod3() {
+ org.citygml4j.model.citygml.tunnel.WallSurface ws = new org.citygml4j.model.citygml.tunnel.WallSurface();
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, ws);
+ bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+ bs.reCreateGeometries(new GMLGeometryFactory(), new ParserConfiguration(8, false));
+ assertNull(ws.getLod2MultiSurface());
+ assertNotNull(ws.getLod3MultiSurface());
+ assertNull(ws.getLod4MultiSurface());
+ }
+
+ @Test
+ public void testReCreateGeometriesMultiSurfaceTunnelLod4() {
+ org.citygml4j.model.citygml.tunnel.WallSurface ws = new org.citygml4j.model.citygml.tunnel.WallSurface();
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, ws);
+ bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+ bs.reCreateGeometries(new GMLGeometryFactory(), new ParserConfiguration(8, false));
+ assertNull(ws.getLod2MultiSurface());
+ assertNull(ws.getLod3MultiSurface());
+ assertNotNull(ws.getLod4MultiSurface());
+ }
+
+ @Test
+ public void testReCreateGeometriesMultiSurfaceLod3() {
+ WallSurface ws = new WallSurface();
+ ws.setId("test");
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+ bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD3));
+ bs.reCreateGeometries(new GMLGeometryFactory(), new ParserConfiguration(8, false));
+ assertNull(ws.getLod2MultiSurface());
+ assertNotNull(ws.getLod3MultiSurface());
+ assertNull(ws.getLod4MultiSurface());
+ }
+
+ @Test
+ public void testReCreateGeometriesMultiSurfaceLod4() {
+ WallSurface ws = new WallSurface();
+ ws.setId("test");
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+ bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD4));
+ bs.reCreateGeometries(new GMLGeometryFactory(), new ParserConfiguration(8, false));
+ assertNull(ws.getLod2MultiSurface());
+ assertNull(ws.getLod3MultiSurface());
+ assertNotNull(ws.getLod4MultiSurface());
+ }
+
+ @Test(expected = IllegalStateException.class)
+ public void testReCreateGeometriesMultiSurfaceLod1() {
+ WallSurface ws = new WallSurface();
+ ws.setId("test");
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+ bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.MULTI_SURFACE, Lod.LOD1));
+ bs.reCreateGeometries(new GMLGeometryFactory(), new ParserConfiguration(8, false));
+ }
+
+ @Test(expected = IllegalStateException.class)
+ public void testReCreateGeometriesSolid() {
+ WallSurface ws = new WallSurface();
+ ws.setId("test");
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+ bs.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID));
+ bs.reCreateGeometries(new GMLGeometryFactory(), new ParserConfiguration(8, false));
+ }
+
+ @Test
+ public void testReCreateGeometriesOpenings() {
+ WallSurface ws = new WallSurface();
+ ws.setId("test");
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+ Opening oMock = Mockito.mock(Opening.class);
+ bs.addOpening(oMock);
+ GMLGeometryFactory factory = new GMLGeometryFactory();
+ ParserConfiguration config = new ParserConfiguration(8, false);
+ bs.reCreateGeometries(factory, config);
+ Mockito.verify(oMock).reCreateGeometries(factory, config);
+ }
+
+ @Test
+ public void testGetGmlObject() {
+ WallSurface ws = new WallSurface();
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+ assertEquals(ws, bs.getGmlObject());
+ }
+
+ @Test
+ public void testUnsetGmlGeometriesBuilding() {
+ WallSurface ws = new WallSurface();
+ ws.setLod2MultiSurface(new MultiSurfaceProperty());
+ ws.setLod3MultiSurface(new MultiSurfaceProperty());
+ ws.setLod4MultiSurface(new MultiSurfaceProperty());
+ assertNotNull(ws.getLod2MultiSurface());
+ assertNotNull(ws.getLod3MultiSurface());
+ assertNotNull(ws.getLod4MultiSurface());
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BUILDING, BoundarySurfaceType.WALL, ws);
+ Opening oMock = Mockito.mock(Opening.class);
+ bs.addOpening(oMock);
+ bs.unsetGmlGeometries();
+ Mockito.verify(oMock).unsetGmlGeometries();
+ assertNull(ws.getLod2MultiSurface());
+ assertNull(ws.getLod3MultiSurface());
+ assertNull(ws.getLod4MultiSurface());
+ }
+
+ @Test
+ public void testUnsetGmlGeometriesBridge() {
+ org.citygml4j.model.citygml.bridge.WallSurface ws = new org.citygml4j.model.citygml.bridge.WallSurface();
+ ws.setLod2MultiSurface(new MultiSurfaceProperty());
+ ws.setLod3MultiSurface(new MultiSurfaceProperty());
+ ws.setLod4MultiSurface(new MultiSurfaceProperty());
+ assertNotNull(ws.getLod2MultiSurface());
+ assertNotNull(ws.getLod3MultiSurface());
+ assertNotNull(ws.getLod4MultiSurface());
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.BRIDGE, BoundarySurfaceType.WALL, ws);
+ bs.unsetGmlGeometries();
+ assertNull(ws.getLod2MultiSurface());
+ assertNull(ws.getLod3MultiSurface());
+ assertNull(ws.getLod4MultiSurface());
+ }
+
+ @Test
+ public void testUnsetGmlGeometriesTunnel() {
+ org.citygml4j.model.citygml.tunnel.WallSurface ws = new org.citygml4j.model.citygml.tunnel.WallSurface();
+ ws.setLod2MultiSurface(new MultiSurfaceProperty());
+ ws.setLod3MultiSurface(new MultiSurfaceProperty());
+ ws.setLod4MultiSurface(new MultiSurfaceProperty());
+ assertNotNull(ws.getLod2MultiSurface());
+ assertNotNull(ws.getLod3MultiSurface());
+ assertNotNull(ws.getLod4MultiSurface());
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, ws);
+ bs.unsetGmlGeometries();
+ assertNull(ws.getLod2MultiSurface());
+ assertNull(ws.getLod3MultiSurface());
+ assertNull(ws.getLod4MultiSurface());
+ }
+
+ @Test(expected = UnsupportedOperationException.class)
+ public void testCopy() {
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, null);
+ bs.copy();
+ }
+
+ @Test
+ public void testGetFeatureType() {
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, null);
+ assertEquals(FeatureType.BOUNDARY_SURFACE, bs.getFeatureType());
+ }
+
+ @Test
+ public void testBoundarySurfaceAbstractCityObject() {
+ AbstractCityObject aco = Mockito.mock(AbstractCityObject.class);
+ BoundarySurface bs = new BoundarySurface(aco);
+ assertEquals(aco, bs.getGmlObject());
+ }
+
+ @Test
+ public void testSetFeatureType() {
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, null);
+ bs.setFeatureType(SurfaceFeatureType.BRIDGE);
+ assertEquals(SurfaceFeatureType.BRIDGE, bs.getSurfaceFeatureType());
+ }
+
+ @Test
+ public void testSetType() {
+ BoundarySurface bs = new BoundarySurface(SurfaceFeatureType.TUNNEL, BoundarySurfaceType.WALL, null);
+ bs.setType(BoundarySurfaceType.ROOF);
+ assertEquals(BoundarySurfaceType.ROOF, bs.getType());
+ }
+
+ @Test
+ public void testSetGmlObject() {
+ AbstractCityObject aco = Mockito.mock(AbstractCityObject.class);
+ BoundarySurface bs = new BoundarySurface(null);
+ bs.setGmlObject(aco);
+ assertEquals(aco, bs.getGmlObject());
+ }
+
+ @Test
+ public void testGetOpenings() {
+ Opening oMock = Mockito.mock(Opening.class);
+ BoundarySurface bs = new BoundarySurface(null);
+ bs.addOpening(oMock);
+ assertEquals(oMock, bs.getOpenings().get(0));
+ }
+
+ @Test
+ public void testSetParent() {
+ BoundarySurface bs = new BoundarySurface(null);
+ CityObject co = Mockito.mock(CityObject.class);
+ bs.setParent(co);
+ assertEquals(co, bs.getParent());
+ }
+}
diff --git a/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryTestUtils.java b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryTestUtils.java
new file mode 100644
index 0000000000000000000000000000000000000000..1b3f78fe55a26d005a6bf95d8bf086df199d3414
--- /dev/null
+++ b/CityDoctorParent/CityDoctorModel/src/test/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryTestUtils.java
@@ -0,0 +1,52 @@
+/*-
+ * Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
+ *
+ * This file is part of CityDoctor2.
+ *
+ * CityDoctor2 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * CityDoctor2 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with CityDoctor2. If not, see <https://www.gnu.org/licenses/>.
+ */
+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
+
+public class GeometryTestUtils {
+
+ private GeometryTestUtils() {
+ }
+
+ public static Geometry createDummyGeometry(GeometryType type) {
+ return createDummyGeometry(type, Lod.LOD2);
+ }
+
+ public static Geometry createDummyGeometry(GeometryType type, Lod lod) {
+ Geometry geom = new Geometry(type, lod);
+ ConcretePolygon polygon = new ConcretePolygon();
+ geom.getPolygons().add(polygon);
+ polygon.setParent(geom);
+ LinearRing lr = new LinearRing(LinearRingType.EXTERIOR);
+ polygon.setExteriorRing(lr);
+ Vertex v1 = new Vertex(427583.301, 6003502.571, 9.711);
+ lr.getVertices().add(v1);
+ Vertex v2 = new Vertex(427583.304, 6003502.574, 9.713);
+ lr.getVertices().add(v2);
+ Vertex v3 = new Vertex(427583.304, 6003502.574, 4.097);
+ lr.getVertices().add(v3);
+ Vertex v4 = new Vertex(427583.301, 6003502.571, 4.097);
+ lr.getVertices().add(v4);
+ lr.getVertices().add(v1);
+ geom.updateEdgesAndVertices();
+ return geom;
+ }
+
+}