change to citygml4j 3.0.0 rc4

change to quality ade 0.1.4

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

@@ -18,16 +18,21 @@
  */
 package de.hft.stuttgart.citydoctor2.check.error;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
-import java.util.Optional;
+import java.util.List;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.Building;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
-import de.hft.stuttgart.quality.model.AttributeMissing;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.SemanticAttributeMissingError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class AttributeMissingErrorTest {
 
@@ -37,10 +42,16 @@ public class AttributeMissingErrorTest {
 		GmlId id = new GmlId("testid");
 		b.setGmlId(id);
 		AttributeMissingError err = new AttributeMissingError(b, "childid", "attr", false);
-		Optional<ValidationError> opt = err.convertToQualityAdeDatastructure();
-		assertTrue(opt.isPresent());
-		ValidationError validationError = opt.get();
-		AttributeMissing adeErr = (AttributeMissing) validationError;
+
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError validationError = errors.get(0).getObject();
+		assertTrue(validationError instanceof SemanticAttributeMissingError);
+
+		SemanticAttributeMissingError adeErr = (SemanticAttributeMissingError) validationError;
 		assertEquals("childid", adeErr.getChildId());
 		assertEquals("attr", adeErr.getAttributeName());
 		assertFalse(adeErr.isGeneric());

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

@@ -22,14 +22,17 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import java.util.Optional;
+import java.util.List;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.Building;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
-import de.hft.stuttgart.quality.model.AttributeWrongValue;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.SemanticAttributeWrongValueError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class AttributeValueWrongErrorTest {
 
@@ -39,10 +42,16 @@ public class AttributeValueWrongErrorTest {
 		GmlId id = new GmlId("testid");
 		b.setGmlId(id);
 		AttributeValueWrongError err = new AttributeValueWrongError(b, "childid", "attr", false);
-		Optional<ValidationError> opt = err.convertToQualityAdeDatastructure();
-		assertTrue(opt.isPresent());
-		ValidationError validationError = opt.get();
-		AttributeWrongValue adeErr = (AttributeWrongValue) validationError;
+		
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError validationError = errors.get(0).getObject();
+		assertTrue(validationError instanceof SemanticAttributeWrongValueError);
+		
+		SemanticAttributeWrongValueError adeErr = (SemanticAttributeWrongValueError) validationError;
 		assertEquals("childid", adeErr.getChildId());
 		assertEquals("attr", adeErr.getAttributeName());
 		assertFalse(adeErr.isGeneric());

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

@@ -21,16 +21,19 @@ package de.hft.stuttgart.citydoctor2.check.error;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import java.util.Optional;
+import java.util.List;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
 import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
-import de.hft.stuttgart.quality.model.ConsecutivePointsSame;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.ConsecutivePointsSameError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class ConsecutivePointSameErrorTest {
 
@@ -42,9 +45,16 @@ public class ConsecutivePointSameErrorTest {
 		Vertex p1 = new Vertex(1, 2, 3);
 		Vertex p2 = new Vertex(4, 5, 6);
 		ConsecutivePointSameError err = new ConsecutivePointSameError(lr, p1, p2);
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
-		ConsecutivePointsSame validationError = (ConsecutivePointsSame) optional.get();
+		
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof ConsecutivePointsSameError);
+		
+		ConsecutivePointsSameError validationError = (ConsecutivePointsSameError) ae;
 		assertEquals(id.getGmlString(), validationError.getLinearRingId());
 		assertEquals(1, validationError.getVertex1().getValue().get(0), 0.00001);
 		assertEquals(4, validationError.getVertex2().getValue().get(0), 0.00001);

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

@@ -23,19 +23,22 @@ import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.ConcretePolygon;
 import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
 import de.hft.stuttgart.citydoctor2.datastructure.GeometryType;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Lod;
 import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
-import de.hft.stuttgart.quality.model.MultipleConnectedComponents;
-import de.hft.stuttgart.quality.model.ValidationError;
-import de.hft.stuttgart.quality.model.jaxb.Component;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.properties.PolygonIdListProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.MultipleComponentsError;
+import de.hft.stuttgart.quality.model.types.PolygonIdList;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class MultipleConnectedComponentsErrorTest {
 
@@ -64,17 +67,23 @@ public class MultipleConnectedComponentsErrorTest {
 		components.add(component2);
 		MultipleConnectedComponentsError err = new MultipleConnectedComponentsError(geom, components);
 		
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
-		MultipleConnectedComponents validationError = (MultipleConnectedComponents) optional.get();
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof MultipleComponentsError);
+
+		MultipleComponentsError validationError = (MultipleComponentsError) ae;
 		assertEquals(geomId.getGmlString(), validationError.getGeometryId());
-		List<Component> adeComponents = validationError.getComponents();
+		List<PolygonIdListProperty> adeComponents = validationError.getComponents();
 		assertEquals(2, adeComponents.size());
-		Component adeComponent1 = adeComponents.get(0);
+		PolygonIdList adeComponent1 = adeComponents.get(0).getObject();
 		assertEquals(2, adeComponent1.getPolygonIds().size());
 		assertEquals(p1Id.getGmlString(), adeComponent1.getPolygonIds().get(0));
 		assertEquals(p2Id.getGmlString(), adeComponent1.getPolygonIds().get(1));
-		Component adeComponent2 = adeComponents.get(1);
+		PolygonIdList adeComponent2 = adeComponents.get(1).getObject();
 		assertEquals(p3Id.getGmlString(), adeComponent2.getPolygonIds().get(0));
 	}
 

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

@@ -21,17 +21,20 @@ package de.hft.stuttgart.citydoctor2.check.error;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import java.util.Optional;
+import java.util.List;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.ConcretePolygon;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
 import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
-import de.hft.stuttgart.quality.model.InnerRingsNested;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.InnerRingsNestedError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class NestedRingErrorTest {
 
@@ -51,10 +54,15 @@ public class NestedRingErrorTest {
 		
 		NestedRingError err = new NestedRingError(p1, r1, r2);
 		
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof InnerRingsNestedError);
 		
-		InnerRingsNested validationError = (InnerRingsNested) optional.get();
+		InnerRingsNestedError validationError = (InnerRingsNestedError) ae;
 		assertEquals(p1Id.getGmlString(), validationError.getPolygonId());
 		assertEquals(r1Id.getGmlString(), validationError.getLinearRingId1());
 		assertEquals(r2Id.getGmlString(), validationError.getLinearRingId2());

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

@@ -23,18 +23,20 @@ import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.Edge;
 import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
 import de.hft.stuttgart.citydoctor2.datastructure.GeometryType;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Lod;
 import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
-import de.hft.stuttgart.quality.model.NonManifoldEdge;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.properties.EdgeProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class NonManifoldEdgeErrorTest {
 
@@ -57,14 +59,19 @@ public class NonManifoldEdgeErrorTest {
 		
 		NonManifoldEdgeError err = new NonManifoldEdgeError(geom, edges);
 		
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof de.hft.stuttgart.quality.model.types.NonManifoldEdgeError);
 		
-		NonManifoldEdge validationError = (NonManifoldEdge) optional.get();
+		var validationError = (de.hft.stuttgart.quality.model.types.NonManifoldEdgeError) ae;
 		assertEquals(geomId.getGmlString(), validationError.getGeometryId());
-		List<de.hft.stuttgart.quality.model.Edge> adeEdges = validationError.getEdges();
-		de.hft.stuttgart.quality.model.Edge adeE1 = adeEdges.get(0);
-		de.hft.stuttgart.quality.model.Edge adeE2 = adeEdges.get(1);
+		List<EdgeProperty> adeEdges = validationError.getEdges().getObject().getEdges();
+		de.hft.stuttgart.quality.model.types.Edge adeE1 = adeEdges.get(0).getObject();
+		de.hft.stuttgart.quality.model.types.Edge adeE2 = adeEdges.get(1).getObject();
 		assertEquals(1, adeE1.getFrom().getValue().get(0), 0.00001);
 		assertEquals(4, adeE1.getTo().getValue().get(0), 0.00001);
 		assertEquals(7, adeE2.getTo().getValue().get(0), 0.00001);

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

@@ -23,10 +23,10 @@ import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.ConcretePolygon;
 import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
 import de.hft.stuttgart.citydoctor2.datastructure.GeometryType;
@@ -34,8 +34,9 @@ import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Lod;
 import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
 import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
-import de.hft.stuttgart.quality.model.NonManifoldVertex;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class NonManifoldVertexErrorTest {
 
@@ -65,12 +66,17 @@ public class NonManifoldVertexErrorTest {
 		
 		Vertex v1 = new Vertex(1, 2, 3);
 
-		
 		NonManifoldVertexError err = new NonManifoldVertexError(geom, components, v1);
 		
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
-		NonManifoldVertex validationError = (NonManifoldVertex) optional.get();
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof de.hft.stuttgart.quality.model.types.NonManifoldVertexError);
+		
+		var validationError = (de.hft.stuttgart.quality.model.types.NonManifoldVertexError) ae;
 		assertEquals(geomId.getGmlString(), validationError.getGeometryId());
 		assertEquals(1, validationError.getVertex().getValue().get(0), 0.0001);
 	}

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

@@ -21,16 +21,19 @@ package de.hft.stuttgart.citydoctor2.check.error;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import java.util.Optional;
+import java.util.List;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.ConcretePolygon;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
 import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
-import de.hft.stuttgart.quality.model.NonPlanarDistancePlane;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.PlanarDistancePlaneError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class NonPlanarPolygonDistancePlaneErrorTest {
 
@@ -43,10 +46,16 @@ public class NonPlanarPolygonDistancePlaneErrorTest {
 		Vertex v = new Vertex(1, 2, 3);
 
 		NonPlanarPolygonDistancePlaneError err = new NonPlanarPolygonDistancePlaneError(p1, 5, v, null);
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
 		
-		NonPlanarDistancePlane error = (NonPlanarDistancePlane) optional.get();
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof PlanarDistancePlaneError);
+		
+		PlanarDistancePlaneError error = (PlanarDistancePlaneError) ae;
 		assertEquals(p1Id.getGmlString(), error.getPolygonId());
 		assertEquals(1, error.getVertex().getValue().get(0), 0.00001);
 		assertEquals(5, error.getDistance().getValue(), 0.000001);

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

@@ -18,17 +18,21 @@
  */
 package de.hft.stuttgart.citydoctor2.check.error;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
-import java.util.Optional;
+import java.util.List;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.ConcretePolygon;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
-import de.hft.stuttgart.quality.model.NonPlanarNormalsDeviation;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.PlanarNormalsDeviationError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class NonPlanarPolygonNormalsDeviationTest {
 
@@ -38,9 +42,16 @@ public class NonPlanarPolygonNormalsDeviationTest {
 		GmlId p1Id = new GmlId("p1Id");
 		p1.setGmlId(p1Id);
 		NonPlanarPolygonNormalsDeviation err = new NonPlanarPolygonNormalsDeviation(p1, 5);
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
-		NonPlanarNormalsDeviation error = (NonPlanarNormalsDeviation) optional.get();
+		
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof PlanarNormalsDeviationError);
+		
+		PlanarNormalsDeviationError error = (PlanarNormalsDeviationError) ae;
 		assertEquals(5, error.getDeviation().getValue(), 0.00001);
 		assertEquals(p1Id.getGmlString(), error.getPolygonId());
 	}

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

@@ -21,17 +21,20 @@ package de.hft.stuttgart.citydoctor2.check.error;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import java.util.Optional;
+import java.util.List;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.Edge;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
 import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
-import de.hft.stuttgart.quality.model.RingSelfIntersection;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.RingSelfIntersectionError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class PointTouchesEdgeErrorTest {
 
@@ -45,13 +48,20 @@ public class PointTouchesEdgeErrorTest {
 		Edge e1 = new Edge(v1, v2);
 
 		PointTouchesEdgeError err = new PointTouchesEdgeError(lr, e1, v1);
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
-		RingSelfIntersection error = (RingSelfIntersection) optional.get();
+		
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof RingSelfIntersectionError);
+		
+		RingSelfIntersectionError error = (RingSelfIntersectionError) ae;
 		assertEquals(id.getGmlString(), error.getLinearRingId());
 		assertEquals(1, error.getVertex1().getValue().get(0), 0.00001);
-		assertEquals(1, error.getEdge1().getFrom().getValue().get(0), 0.000001);
-		assertEquals(4, error.getEdge1().getTo().getValue().get(0), 0.000001);
+		assertEquals(1, error.getEdge1().getObject().getFrom().getValue().get(0), 0.000001);
+		assertEquals(4, error.getEdge1().getObject().getTo().getValue().get(0), 0.000001);
 	}
 
 }

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

@@ -23,17 +23,19 @@ import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.ConcretePolygon;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
 import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
-import de.hft.stuttgart.quality.model.HoleOutside;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.HoleOutsideError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class PolygonHoleOutsideErrorTest {
 
@@ -52,10 +54,15 @@ public class PolygonHoleOutsideErrorTest {
 
 		PolygonHoleOutsideError err = new PolygonHoleOutsideError(p1, rings);
 		
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof HoleOutsideError);
 		
-		HoleOutside validationError = (HoleOutside) optional.get();
+		HoleOutsideError validationError = (HoleOutsideError) ae;
 		assertEquals(p1Id.getGmlString(), validationError.getPolygonId());
 		assertEquals(r1Id.getGmlString(), validationError.getLinearRingId());
 

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

@@ -21,15 +21,18 @@ package de.hft.stuttgart.citydoctor2.check.error;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import java.util.Optional;
+import java.util.List;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.ConcretePolygon;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
-import de.hft.stuttgart.quality.model.InteriorDisconnected;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.InteriorDisconnectedError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class PolygonInteriorDisconnectedErrorTest {
 
@@ -40,9 +43,16 @@ public class PolygonInteriorDisconnectedErrorTest {
 		p1.setGmlId(p1Id);
 
 		PolygonInteriorDisconnectedError err = new PolygonInteriorDisconnectedError(p1, null);
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
-		InteriorDisconnected adeErr = (InteriorDisconnected) optional.get();
+		
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof InteriorDisconnectedError);
+		
+		InteriorDisconnectedError adeErr = (InteriorDisconnectedError) ae;
 		assertEquals(p1Id.getGmlString(), adeErr.getPolygonId());
 	}
 

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

@@ -18,20 +18,24 @@
  */
 package de.hft.stuttgart.citydoctor2.check.error;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
-import java.util.Optional;
+import java.util.List;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.ConcretePolygon;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
-import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
+import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
 import de.hft.stuttgart.citydoctor2.utils.SerializablePair;
-import de.hft.stuttgart.quality.model.IntersectingRings;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.IntersectingRingsError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class PolygonIntersectingRingsErrorTest {
 
@@ -52,9 +56,16 @@ public class PolygonIntersectingRingsErrorTest {
 		SerializablePair<LinearRing, LinearRing> pair = new SerializablePair<>(r1, r2);
 		
 		PolygonIntersectingRingsError err = new PolygonIntersectingRingsError(p1, pair);
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
-		IntersectingRings error = (IntersectingRings) optional.get();
+		
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof IntersectingRingsError);
+		
+		IntersectingRingsError error = (IntersectingRingsError) ae;
 		assertEquals(p1Id.getGmlString(), error.getPolygonId());
 		assertEquals(r1Id.getGmlString(), error.getLinearRingId1());
 		assertEquals(r2Id.getGmlString(), error.getLinearRingId2());

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

@@ -21,17 +21,20 @@ package de.hft.stuttgart.citydoctor2.check.error;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import java.util.Optional;
+import java.util.List;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.ConcretePolygon;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
 import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
-import de.hft.stuttgart.quality.model.OrientationRingsSame;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.OrientationRingsSameError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class PolygonSameOrientationErrorTest {
 
@@ -44,15 +47,19 @@ public class PolygonSameOrientationErrorTest {
 		LinearRing r1 = new LinearRing(LinearRingType.INTERIOR);
 		GmlId r1Id = new GmlId("r1Id");
 		r1.setGmlId(r1Id);
-
-		
 		PolygonSameOrientationError err = new PolygonSameOrientationError(p1, r1);
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
 		
-		OrientationRingsSame adeErr = (OrientationRingsSame) optional.get();
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof OrientationRingsSameError);
+		
+		OrientationRingsSameError adeErr = (OrientationRingsSameError) ae;
 		assertEquals(p1Id.getGmlString(), adeErr.getPolygonId());
-		assertEquals(r1Id.getGmlString(), adeErr.getLinearRingId());
+		assertEquals(r1Id.getGmlString(), adeErr.getLinearRing());
 	}
 
 }

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

@@ -18,22 +18,25 @@
  */
 package de.hft.stuttgart.citydoctor2.check.error;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.Edge;
 import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
 import de.hft.stuttgart.citydoctor2.datastructure.GeometryType;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Lod;
 import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
-import de.hft.stuttgart.quality.model.PolygonWrongOrientation;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.properties.EdgeProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class PolygonWrongOrientationErrorTest {
 
@@ -54,15 +57,21 @@ public class PolygonWrongOrientationErrorTest {
 		edges.add(e1);
 		edges.add(e2);
 
-		
 		PolygonWrongOrientationError err = new PolygonWrongOrientationError(geom, edges);
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
-		PolygonWrongOrientation adeErr = (PolygonWrongOrientation) optional.get();
+		
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof de.hft.stuttgart.quality.model.types.PolygonWrongOrientationError);
+		
+		var adeErr = (de.hft.stuttgart.quality.model.types.PolygonWrongOrientationError) ae;
 		assertEquals(geomId.getGmlString(), adeErr.getGeometryId());
-		List<de.hft.stuttgart.quality.model.Edge> adeEdges = adeErr.getEdges();
-		de.hft.stuttgart.quality.model.Edge adeE1 = adeEdges.get(0);
-		de.hft.stuttgart.quality.model.Edge adeE2 = adeEdges.get(1);
+		 List<EdgeProperty> adeEdges = adeErr.getEdges().getObject().getEdges();
+		de.hft.stuttgart.quality.model.types.Edge adeE1 = adeEdges.get(0).getObject();
+		de.hft.stuttgart.quality.model.types.Edge adeE2 = adeEdges.get(1).getObject();
 		assertEquals(1, adeE1.getFrom().getValue().get(0), 0.00001);
 		assertEquals(4, adeE1.getTo().getValue().get(0), 0.00001);
 		assertEquals(7, adeE2.getTo().getValue().get(0), 0.00001);

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

@@ -21,16 +21,19 @@ package de.hft.stuttgart.citydoctor2.check.error;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import java.util.Optional;
+import java.util.List;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
 import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
-import de.hft.stuttgart.quality.model.RingSelfIntersection;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.RingSelfIntersectionError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class RingDuplicatePointErrorTest {
 
@@ -43,9 +46,16 @@ public class RingDuplicatePointErrorTest {
 		Vertex p2 = new Vertex(4, 5, 6);
 
 		RingDuplicatePointError err = new RingDuplicatePointError(lr, p1, p2);
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
-		RingSelfIntersection adeErr = (RingSelfIntersection) optional.get();
+
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof RingSelfIntersectionError);
+
+		RingSelfIntersectionError adeErr = (RingSelfIntersectionError) ae;
 		assertEquals(id.getGmlString(), adeErr.getLinearRingId());
 		assertEquals(1, adeErr.getVertex1().getValue().get(0), 0.00001);
 		assertEquals(4, adeErr.getVertex2().getValue().get(0), 0.00001);

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

@@ -18,19 +18,23 @@
  */
 package de.hft.stuttgart.citydoctor2.check.error;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
-import java.util.Optional;
+import java.util.List;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.Edge;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
-import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
-import de.hft.stuttgart.quality.model.RingSelfIntersection;
-import de.hft.stuttgart.quality.model.ValidationError;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
+import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.RingSelfIntersectionError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class RingEdgeIntersectionErrorTest {
 
@@ -46,15 +50,21 @@ public class RingEdgeIntersectionErrorTest {
 		Edge e2 = new Edge(v2, v3);
 
 		RingEdgeIntersectionError err = new RingEdgeIntersectionError(lr, e1, e2, v1);
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
 		
-		RingSelfIntersection adeErr = (RingSelfIntersection) optional.get();
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof RingSelfIntersectionError);
+		
+		RingSelfIntersectionError adeErr = (RingSelfIntersectionError) ae;
 		assertEquals(id.getGmlString(), adeErr.getLinearRingId());
-		assertEquals(1, adeErr.getEdge1().getFrom().getValue().get(0), 0.00001);
-		assertEquals(4, adeErr.getEdge1().getTo().getValue().get(0), 0.00001);
-		assertEquals(4, adeErr.getEdge2().getFrom().getValue().get(0), 0.00001);
-		assertEquals(7, adeErr.getEdge2().getTo().getValue().get(0), 0.00001);
+		assertEquals(1, adeErr.getEdge1().getObject().getFrom().getValue().get(0), 0.00001);
+		assertEquals(4, adeErr.getEdge1().getObject().getTo().getValue().get(0), 0.00001);
+		assertEquals(4, adeErr.getEdge2().getObject().getFrom().getValue().get(0), 0.00001);
+		assertEquals(7, adeErr.getEdge2().getObject().getTo().getValue().get(0), 0.00001);
 		assertEquals(1, adeErr.getVertex1().getValue().get(0), 0.00001);
 	}
 

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

@@ -18,17 +18,20 @@
  */
 package de.hft.stuttgart.citydoctor2.check.error;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
-import java.util.Optional;
+import java.util.List;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
-import de.hft.stuttgart.quality.model.RingNotClosed;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class RingNotClosedErrorTest {
 
@@ -39,10 +42,16 @@ public class RingNotClosedErrorTest {
 		r1.setGmlId(r1Id);
 		
 		RingNotClosedError err = new RingNotClosedError(r1);
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
 		
-		RingNotClosed adeErr = (RingNotClosed) optional.get();
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof de.hft.stuttgart.quality.model.types.RingNotClosedError);
+		
+		var adeErr = (de.hft.stuttgart.quality.model.types.RingNotClosedError) ae;
 		assertEquals(r1Id.getGmlString(), adeErr.getLinearRingId());
 	}
 

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

@@ -21,15 +21,17 @@ package de.hft.stuttgart.citydoctor2.check.error;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import java.util.Optional;
+import java.util.List;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing.LinearRingType;
-import de.hft.stuttgart.quality.model.TooFewPoints;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class RingTooFewPointsErrorTest {
 
@@ -40,10 +42,16 @@ public class RingTooFewPointsErrorTest {
 		r1.setGmlId(r1Id);
 
 		RingTooFewPointsError err = new RingTooFewPointsError(r1);
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
-
-		TooFewPoints adeErr = (TooFewPoints) optional.get();
+		
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof de.hft.stuttgart.quality.model.types.RingTooFewPointsError);
+		
+		var adeErr = (de.hft.stuttgart.quality.model.types.RingTooFewPointsError) ae;
 		assertEquals(r1Id.getGmlString(), adeErr.getLinearRingId());
 	}
 

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

@@ -23,18 +23,20 @@ import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 
 import org.junit.Test;
 
+import de.hft.stuttgart.citydoctor2.check.QualityAdeErrorVisitor;
 import de.hft.stuttgart.citydoctor2.datastructure.Edge;
 import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
 import de.hft.stuttgart.citydoctor2.datastructure.GeometryType;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.Lod;
 import de.hft.stuttgart.citydoctor2.datastructure.Vertex;
-import de.hft.stuttgart.quality.model.SolidNotClosed;
-import de.hft.stuttgart.quality.model.ValidationError;
+import de.hft.stuttgart.quality.model.properties.AbstractErrorProperty;
+import de.hft.stuttgart.quality.model.properties.EdgeProperty;
+import de.hft.stuttgart.quality.model.types.AbstractError;
+import de.hft.stuttgart.quality.model.types.ValidationResult;
 
 public class SolidNotClosedErrorTest {
 
@@ -57,14 +59,19 @@ public class SolidNotClosedErrorTest {
 		
 		SolidNotClosedError err = new SolidNotClosedError(geom, edges);
 		
-		Optional<ValidationError> optional = err.convertToQualityAdeDatastructure();
-		assertTrue(optional.isPresent());
+		ValidationResult result = new ValidationResult();
+		QualityAdeErrorVisitor visitor = new QualityAdeErrorVisitor(result);
+		err.accept(visitor);
+		List<AbstractErrorProperty> errors = result.getErrors();
+		assertEquals(1, errors.size());
+		AbstractError ae = errors.get(0).getObject();
+		assertTrue(ae instanceof de.hft.stuttgart.quality.model.types.SolidNotClosedError);
 		
-		SolidNotClosed validationError = (SolidNotClosed) optional.get();
+		var validationError = (de.hft.stuttgart.quality.model.types.SolidNotClosedError) ae;
 		assertEquals(geomId.getGmlString(), validationError.getGeometryId());
-		List<de.hft.stuttgart.quality.model.Edge> adeEdges = validationError.getEdges();
-		de.hft.stuttgart.quality.model.Edge adeE1 = adeEdges.get(0);
-		de.hft.stuttgart.quality.model.Edge adeE2 = adeEdges.get(1);
+		List<EdgeProperty> adeEdges = validationError.getEdges().getObject().getEdges();
+		de.hft.stuttgart.quality.model.types.Edge adeE1 = adeEdges.get(0).getObject();
+		de.hft.stuttgart.quality.model.types.Edge adeE2 = adeEdges.get(1).getObject();
 		assertEquals(1, adeE1.getFrom().getValue().get(0), 0.00001);
 		assertEquals(4, adeE1.getTo().getValue().get(0), 0.00001);
 		assertEquals(7, adeE2.getTo().getValue().get(0), 0.00001);