Commit fde5999f authored by Matthias Betz's avatar Matthias Betz
Browse files

Fixed a bug with writing the wrong quality ade namespace

Added CityDoctorModel tests
parent 38229af8
Pipeline #2404 passed with stage
in 3 minutes and 17 seconds
......@@ -140,7 +140,7 @@ public class CityDoctorModel {
if (isValidated) {
writer.setPrefix("qual", QualityADEModule.NAMESPACE_URI);
writer.setSchemaLocation(QualityADEModule.NAMESPACE_URI,
"https://transfer.hft-stuttgart.de/pages/qualityade/0.1/qualityAde.xsd");
QualityADEModule.NAMESPACE_URI + "qualityAde.xsd");
// remove old model if available
QualityADEUtils.removeValidation(cModel);
......
/*-
* 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.assertTrue;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.citygml4j.builder.jaxb.CityGMLBuilderException;
import org.citygml4j.model.citygml.ade.ADEComponent;
import org.citygml4j.model.citygml.ade.ADEException;
import org.citygml4j.model.citygml.core.CityModel;
import org.citygml4j.xml.io.writer.CityGMLWriteException;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
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.ErrorId;
import de.hft.stuttgart.citydoctor2.check.ErrorReport;
import de.hft.stuttgart.citydoctor2.check.ErrorType;
import de.hft.stuttgart.citydoctor2.check.ErrorVisitor;
import de.hft.stuttgart.citydoctor2.check.HealingMethod;
import de.hft.stuttgart.citydoctor2.check.ModificationListener;
import de.hft.stuttgart.citydoctor2.check.ResultStatus;
import de.hft.stuttgart.citydoctor2.parser.CityGmlParseException;
import de.hft.stuttgart.citydoctor2.parser.CityGmlParser;
import de.hft.stuttgart.citydoctor2.parser.InvalidGmlFileException;
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
import de.hft.stuttgart.quality.model.Validation;
import de.hft.stuttgart.quality.model.jaxb.ErrorStatistics;
import de.hft.stuttgart.quality.model.jaxb.Parameter;
import de.hft.stuttgart.quality.model.jaxb.ValidationPlan;
public class CityDoctorModelTest {
@Rule
public TemporaryFolder folder = new TemporaryFolder();
@Test(expected = IllegalArgumentException.class)
public void testCityDoctorModelNoConfig() {
new CityDoctorModel(null, null);
}
@Test
public void testSetValidated() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
model.setValidated(Mockito.mock(ValidationPlan.class));
assertTrue(model.isValidated());
}
@Test
public void testAddGlobalError() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
CheckError err = Mockito.mock(CheckError.class);
model.addGlobalError(err);
assertEquals(err, model.getGlobalErrors().get(0));
}
@Test
public void testAddGlobalErrors() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
CheckError err1 = Mockito.mock(CheckError.class);
CheckError err2 = Mockito.mock(CheckError.class);
List<CheckError> errors = new ArrayList<>();
errors.add(err1);
errors.add(err2);
model.addGlobalErrors(errors);
assertTrue(model.getGlobalErrors().contains(err1));
assertTrue(model.getGlobalErrors().contains(err2));
}
@Test
public void testGetFile() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
assertEquals(f, model.getFile());
}
@Test
public void testCreateFeatureStream() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
Building b = Mockito.mock(Building.class);
Vegetation v = Mockito.mock(Vegetation.class);
model.addBuilding(b);
model.addVegetation(v);
assertTrue(model.createFeatureStream().anyMatch(c -> c == b));
assertTrue(model.createFeatureStream().anyMatch(c -> c == v));
}
@Test
public void testSaveAsWithoutValidation() throws CityGMLBuilderException, CityGMLWriteException, ADEException,
IOException, CityGmlParseException, InvalidGmlFileException {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
CityModel cModel = new CityModel();
model.setCityModel(cModel);
Building b = new Building();
b.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID));
org.citygml4j.model.citygml.building.Building gmlBuilding = new org.citygml4j.model.citygml.building.Building();
gmlBuilding.setId("testId");
b.setGmlObject(gmlBuilding);
model.addBuilding(b);
File saveFile = folder.newFile();
model.saveAs(saveFile.getAbsolutePath());
assertTrue(saveFile.exists());
assertTrue(saveFile.length() > 0);
CityDoctorModel parsedModel = CityGmlParser.parseCityGmlFile(saveFile.getAbsolutePath(), config);
Building parsedBuilding = parsedModel.getBuildings().get(0);
assertEquals("testId", parsedBuilding.getGmlId().getGmlString());
assertEquals(1, parsedBuilding.getGeometries().size());
}
@Test
public void testSaveAsWithValidation() throws CityGMLBuilderException, CityGMLWriteException, ADEException,
IOException, CityGmlParseException, InvalidGmlFileException {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
CityModel cModel = new CityModel();
ValidationPlan plan = new ValidationPlan();
plan.getGlobalParameters().add(new Parameter());
model.setValidated(plan);
model.setCityModel(cModel);
Building b = new Building();
b.accept(Mockito.mock(Check.class));
CheckError error = new CheckError() {
private static final long serialVersionUID = -5620026648733746435L;
@Override
public ErrorType getType() {
return ErrorType.ERROR;
}
@Override
public ErrorId getErrorId() {
return ErrorId.GE_P_HOLE_OUTSIDE;
}
@Override
public GmlElement getFeature() {
return null;
}
@Override
public void accept(ErrorVisitor errorVisitor) {
}
@Override
public boolean accept(HealingMethod method, ModificationListener l) {
return false;
}
@Override
public void report(ErrorReport report) {
}
};
b.addCheckResult(new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, error));
b.addGeometry(GeometryTestUtils.createDummyGeometry(GeometryType.SOLID));
org.citygml4j.model.citygml.building.Building gmlBuilding = new org.citygml4j.model.citygml.building.Building();
gmlBuilding.setId("testId");
b.setGmlObject(gmlBuilding);
model.addBuilding(b);
File saveFile = folder.newFile();
model.saveAs(saveFile.getAbsolutePath());
assertTrue(saveFile.exists());
assertTrue(saveFile.length() > 0);
CityDoctorModel parsedModel = CityGmlParser.parseCityGmlFile(saveFile.getAbsolutePath(), config);
Building parsedBuilding = parsedModel.getBuildings().get(0);
assertEquals("testId", parsedBuilding.getGmlId().getGmlString());
assertEquals(1, parsedBuilding.getGeometries().size());
assertEquals(1, parsedBuilding.getGmlObject().getGenericApplicationPropertyOfCityObject().size());
assertEquals(1, parsedModel.getCityModel().getGenericApplicationPropertyOfCityModel().size());
List<ADEComponent> adeComps = parsedModel.getCityModel().getGenericApplicationPropertyOfCityModel();
ADEComponent adeComponent = adeComps.get(0);
Validation val = (Validation) adeComponent;
ErrorStatistics errorStatistics = val.getStatistics().getErrorStatistics().get(0);
assertEquals(de.hft.stuttgart.quality.model.jaxb.ErrorId.GE_P_HOLE_OUTSIDE, errorStatistics.getName());
assertEquals(1, errorStatistics.getAmount());
}
@Test
public void testCollectErrors() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
Building b = new Building();
model.addBuilding(b);
CheckError error = Mockito.mock(CheckError.class);
CheckResult result = new CheckResult(CheckId.C_GE_P_HOLE_OUTSIDE, ResultStatus.ERROR, error);
b.addCheckResult(result);
assertTrue(model.collectErrors().contains(error));
}
@Test
public void testGetFileName() {
File f = new File("test");
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
assertEquals("test", model.getFileName());
assertEquals(f, model.getFile());
}
@Test
public void testAddBridge() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
BridgeObject b = Mockito.mock(BridgeObject.class);
model.addBridge(b);
assertEquals(b, model.getBridges().get(0));
}
@Test
public void testAddBuilding() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
Building b = Mockito.mock(Building.class);
model.addBuilding(b);
assertEquals(b, model.getBuildings().get(0));
}
@Test
public void testSetCityModel() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
CityModel cModel = Mockito.mock(CityModel.class);
model.setCityModel(cModel);
assertEquals(cModel, model.getCityModel());
}
@Test
public void testAddWater() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
WaterObject water = Mockito.mock(WaterObject.class);
model.addWater(water);
assertEquals(water, model.getWater().get(0));
}
@Test
public void testAddLand() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
LandObject land = Mockito.mock(LandObject.class);
model.addLand(land);
assertEquals(land, model.getLand().get(0));
}
@Test
public void testAddVegetation() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
Vegetation veg = Mockito.mock(Vegetation.class);
model.addVegetation(veg);
assertEquals(veg, model.getVegetation().get(0));
}
@Test
public void testAddTransportation() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
TransportationObject trans = Mockito.mock(TransportationObject.class);
model.addTransportation(trans);
assertEquals(trans, model.getTransportation().get(0));
}
@Test
public void testGetNumberOfFeatures() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
Building b = Mockito.mock(Building.class);
TransportationObject trans = Mockito.mock(TransportationObject.class);
model.addBuilding(b);
model.addTransportation(trans);
assertEquals(2, model.getNumberOfFeatures());
}
@Test
public void testGetParserConfig() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
assertEquals(config, model.getParserConfig());
}
@Test
public void testReplaceFeature() {
File f = Mockito.mock(File.class);
ParserConfiguration config = new ParserConfiguration(8, false);
CityDoctorModel model = new CityDoctorModel(config, f);
Building b1 = Mockito.mock(Building.class);
Building b2 = Mockito.mock(Building.class);
model.addBuilding(b1);
assertEquals(b1, model.getBuildings().get(0));
model.replaceFeature(b1, b2);
assertEquals(b2, model.getBuildings().get(0));
}
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment