public void CanReportNonUniquePointIds()
{
FeatureClassMock featureClassMock = CreateFeatureClassMock();
var construction = new MultiPatchConstruction();
const int id1 = 1;
const int id2 = 2;
construction.StartOuterRing(0, 0, 0, id1)
.Add(10, 0, 0, id2)
.Add(10, 10, 0, id2)
.Add(0, 10, 0, id2);
IFeature row = featureClassMock.CreateFeature(construction.MultiPatch);
const bool allowIntersectionsForDifferentPointIds = true;
var test = new QaMpNonIntersectingRingFootprints(featureClassMock,
allowIntersectionsForDifferentPointIds);
var runner = new QaTestRunner(test);
runner.Execute(row);
// only reported if allowIntersectionsForDifferentPointIds == true
AssertUtils.OneError(runner,
"MpNonIntersectingRingFootprints.PointIdNotUniqueWithinFace");
}
public void CanTestPolylineFeaturePath()
{
IFeatureClass fc = new FeatureClassMock(1, "LineFc",
esriGeometryType.esriGeometryPolyline);
IFeature feature = fc.CreateFeature();
IPolycurve correctPath = CurveConstruction.StartLine(100, 100)
.LineTo(110, 110)
.Curve;
// note: union converts linear circular arcs to lines -> make sure the arc is not linear
IPolycurve incorrectPath = CurveConstruction.StartLine(0, 0)
.LineTo(10, 10)
.CircleTo(30, 10)
.Curve;
feature.Shape = GeometryUtils.Union(correctPath, incorrectPath);
feature.Store();
var test = new QaGeometryConstraint(fc, "$CircularArcCount = 0", perPart: true);
var runner = new QaTestRunner(test);
runner.Execute(feature);
QaError error;
AssertUtils.OneError(runner,
"GeometryConstraint.ConstraintNotFulfilled.ForShapePart",
out error);
Assert.True(GeometryUtils.AreEqual(incorrectPath,
GeometryFactory.CreatePolyline(error.Geometry)));
}
public void CanReportIntersectingFootPrints()
{
FeatureClassMock featureClassMock = CreateFeatureClassMock();
var construction = new MultiPatchConstruction();
const int id1 = 1;
construction.StartOuterRing(0, 0, 0, id1)
.Add(10, 0, 0, id1)
.Add(10, 10, 0, id1)
.Add(0, 10, 0, id1)
.StartOuterRing(9, 0, 10, id1)
.Add(20, 0, 10, id1)
.Add(20, 10, 10, id1)
.Add(9, 10, 10, id1);
IFeature row = featureClassMock.CreateFeature(construction.MultiPatch);
const bool allowIntersectionsForDifferentPointIds = true;
var test = new QaMpNonIntersectingRingFootprints(featureClassMock,
allowIntersectionsForDifferentPointIds);
var runner = new QaTestRunner(test);
runner.Execute(row);
AssertUtils.OneError(runner,
"MpNonIntersectingRingFootprints.RingFootprintsIntersect");
}
public void CanReportMultipartFootPrintVerticalWall()
{
FeatureClassMock featureClassMock = CreateFeatureClassMock();
var construction = new MultiPatchConstruction();
// second ring is vertical wall, disjoint from first ring
construction.StartOuterRing(0, 0, 0)
.Add(10, 0, 0)
.Add(10, 10, 0)
.Add(0, 10, 0)
.StartOuterRing(20, 0, 100)
.Add(30, 0, 100)
.Add(30, 0, 110)
.Add(20, 0, 110);
IFeature row = featureClassMock.CreateFeature(construction.MultiPatch);
var test = new QaMpSinglePartFootprint(featureClassMock);
var runner = new QaTestRunner(test);
runner.Execute(row);
AssertUtils.OneError(runner, "MpSinglePartFootprint.FootprintHasMultipleParts");
}
public void CanReportNoVertexOnNearbyEdgeLineErrorInLeftTile()
{
const string testName = "CanReportNoVertexOnNearbyEdgeLineErrorInLeftTile";
IFeatureClass vertexClass = CreateFeatureClass(
$"{testName}_vertex", esriGeometryType.esriGeometryPolyline);
IFeature lineRow = vertexClass.CreateFeature();
lineRow.Shape = CurveConstruction.StartLine(300, 100)
.LineTo(201, 100)
.Curve;
lineRow.Store();
IFeature lineRow2 = vertexClass.CreateFeature();
lineRow2.Shape = CurveConstruction.StartLine(199, 150)
.LineTo(199, 50)
.Curve;
lineRow2.Store();
IEnvelope verificationEnvelope =
GeometryFactory.CreateEnvelope(0, 0, 500, 500);
var test = new QaVertexCoincidenceSelf(vertexClass)
{
EdgeTolerance = 3
};
var runner = new QaContainerTestRunner(200, test);
runner.Execute(verificationEnvelope);
AssertUtils.OneError(runner,
"VertexCoincidence.NoVertexOnNearbyEdge.DifferentFeature");
}
public void TestNonEqualXCoordinateDoubleField()
{
var featureClass = new FeatureClassMock(1, "Fc", esriGeometryType.esriGeometryPoint);
featureClass.AddField(FieldUtils.CreateDoubleField(_fieldNameX));
// create point feature
const double x = 2600000;
const double y = 1200000;
const double z = 500;
IFeature feature = CreateFeature(featureClass,
x, x + 1.01 * _xyTolerance,
y, null,
z, null);
var test = new QaValidCoordinateFields(featureClass,
_fieldNameX, null, null,
_xyTolerance, _zTolerance, _culture);
var runner = new QaTestRunner(test);
runner.Execute(feature);
QaError error;
AssertUtils.OneError(runner,
"ValidCoordinateFields.XYFieldCoordinateValueTooFarFromShape",
out error);
Assert.AreEqual(_fieldNameX, error.AffectedComponent);
}
public void TestNonEqualCoordinatesTextFieldsBothXYJustBelowTolerance()
{
var featureClass = new FeatureClassMock(1, "Fc", esriGeometryType.esriGeometryPoint);
featureClass.AddField(FieldUtils.CreateTextField(_fieldNameX, 50));
featureClass.AddField(FieldUtils.CreateTextField(_fieldNameY, 50));
featureClass.AddField(FieldUtils.CreateTextField(_fieldNameZ, 50));
// create point feature
const double x = 2600000.12345;
const double y = 1200000.12345;
IFeature feature = CreateFeature(
featureClass,
x, string.Format(_cultureInfo, "{0:N3}", x + 0.9 * _xyTolerance),
y, string.Format(_cultureInfo, "{0:N3}", y - 0.9 * _xyTolerance),
z: 100, zFieldValue: "100");
var test = new QaValidCoordinateFields(featureClass,
_fieldNameX, _fieldNameY, _fieldNameZ,
_xyTolerance, _zTolerance, _culture);
var runner = new QaTestRunner(test);
runner.Execute(feature);
AssertUtils.OneError(runner,
"ValidCoordinateFields.XYFieldCoordinatesTooFarFromShape");
}
private static void AssertOneErrorEmptyGeometry(IFeatureClass featureClass)
{
var test = new QaNonEmptyGeometry(featureClass);
var runner = new QaTestRunner(test);
runner.Execute();
QaError error;
AssertUtils.OneError(runner, "EmptyGeometry.GeometryEmpty", out error);
}
public void CanReportAllInteriorRingsCombined()
{
QaTestRunner testRunner = RunTestOnFeature();
QaError error;
AssertUtils.OneError(testRunner, "InteriorRings.UnallowedInteriorRings", out error);
// message from previous releases, must be maintained for these parameters
Assert.AreEqual(
"Polygon has 4 interior ring(s), the maximum allowed number of interior rings is 0",
error.Description);
}
public void CanReportSmallInteriorRingsCombined()
{
QaTestRunner testRunner = RunTestOnFeature(maximumInteriorRingCount: 0,
ignoreInnerRingsLargerThan: 10);
QaError error;
AssertUtils.OneError(testRunner, "InteriorRings.UnallowedInteriorRings", out error);
Assert.AreEqual(
"Polygon has 4 interior ring(s), of which 1 is smaller than the minimum area (10)",
error.Description);
AssertErrorPartCount(1, error);
}
public void CanReportErrorUseMultipleTolerancesInTileLeft()
{
const string testName = "CanReportErrorUseMultipleTolerancesInTileLeft";
IFeatureClass nodeClass = CreateFeatureClass(string.Format("{0}_node", testName),
esriGeometryType.esriGeometryPoint);
IFeatureClass nearClass = CreateFeatureClass(string.Format("{0}_near", testName),
esriGeometryType.esriGeometryPolyline);
IFeatureClass nearClass1 = CreateFeatureClass(string.Format("{0}_near1", testName),
esriGeometryType.esriGeometryPolyline);
var nearClasses = new List <IFeatureClass> {
nearClass, nearClass1
};
IFeature nodeRow = nodeClass.CreateFeature();
nodeRow.Shape = GeometryFactory.CreatePoint(201, 199);
nodeRow.Store();
IFeature nearRow = nearClass.CreateFeature();
nearRow.Shape = CurveConstruction.StartLine(199, 198)
.LineTo(100, 100)
.Curve;
nearRow.Store();
IFeature nearRow1 = nearClass1.CreateFeature();
nearRow1.Shape = CurveConstruction.StartLine(100, 205)
.LineTo(199, 199)
.LineTo(100, 103)
.Curve;
nearRow1.Store();
IEnvelope verificationEnvelope = GeometryFactory.CreateEnvelope(0, 0, 500, 500);
var test = new QaNodeLineCoincidence(nodeClass, nearClasses,
new List <double> {
2.0, 3.0
}, 0, false, false);
var runner = new QaContainerTestRunner(200, test);
runner.Execute(verificationEnvelope);
AssertUtils.OneError(runner,
"NodeLineCoincidence.NodeTooCloseToLine.BetweenFeatures");
}
public void CanDetectTooFewRows()
{
var verified = new FeatureClassMock(1, "v", _gt)
{
RowCountResult = 999
};
var test = new QaRowCount(verified, 1000, 2000);
var runner = new QaTestRunner(test);
runner.Execute();
AssertUtils.OneError(runner, "RowCount.TooFewRows");
}
public void CanReportSurplusInteriorRingsCombinedAllRings()
{
QaTestRunner testRunner = RunTestOnFeature(
maximumInteriorRingCount: 2,
reportOnlySmallestRingsExceedingMaximumCount: false);
QaError error;
AssertUtils.OneError(testRunner, "InteriorRings.UnallowedInteriorRings", out error);
Assert.AreEqual(
"Polygon has 4 interior ring(s), the maximum allowed number of interior rings is 2",
error.Description);
AssertErrorPartCount(4, error);
}
public void CanReportSurplusSmallInteriorRingsCombinedAllRings()
{
QaTestRunner testRunner = RunTestOnFeature(
maximumInteriorRingCount: 2,
ignoreInnerRingsLargerThan: 200,
reportOnlySmallestRingsExceedingMaximumCount: false);
QaError error;
AssertUtils.OneError(testRunner, "InteriorRings.UnallowedInteriorRings", out error);
Assert.AreEqual(
"Polygon has 4 interior ring(s), of which 3 are smaller than the minimum area (200); " +
"the maximum allowed number of interior rings is 2",
error.Description);
AssertErrorPartCount(3, error);
}
public void CanTestNullGeometry()
{
IFeatureClass fc = new FeatureClassMock(1, "LineFc",
esriGeometryType.esriGeometryPolyline);
IFeature feature = fc.CreateFeature();
feature.Shape = null;
feature.Store();
var test = new QaNonEmptyGeometry(fc);
var runner = new QaTestRunner(test);
runner.Execute(feature);
QaError error;
AssertUtils.OneError(runner, "EmptyGeometry.GeometryNull", out error);
}
public void CanDetectTooManyRowsWithOffset()
{
var verified = new FeatureClassMock(1, "v", _gt)
{
RowCountResult = 1101
};
var r = new FeatureClassMock(2, "r1", _gt)
{
RowCountResult = 1000
};
var test = new QaRowCount(verified, new ITable[] { r }, "-100", "+100");
var runner = new QaTestRunner(test);
runner.Execute();
AssertUtils.OneError(runner, "RowCount.TooManyRows");
}
public void CanTestNullGeometry_DontFilterPolycurvesByZeroLength()
{
IFeatureClass fc = new FeatureClassMock(1, "LineFc",
esriGeometryType.esriGeometryPolyline);
IFeature feature = fc.CreateFeature();
feature.Shape = null;
feature.Store();
const bool dontFilterPolycurvesByZeroLength = true;
var test = new QaNonEmptyGeometry(fc, dontFilterPolycurvesByZeroLength);
var runner = new QaTestRunner(test);
runner.Execute(feature);
QaError error;
AssertUtils.OneError(runner, "EmptyGeometry.GeometryNull", out error);
}
public void CanReportNearlyCoincidentSectionErrorInLeftTile()
{
const string testName = "CanReportNearlyCoincidentSectionErrorInLeftTile";
IFeatureClass testedClass =
CreateFeatureClass(string.Format("{0}_tested", testName),
esriGeometryType.esriGeometryPolyline);
IFeatureClass referenceClass =
CreateFeatureClass(string.Format("{0}_reference", testName),
esriGeometryType.esriGeometryPolyline);
IFeature testedRow = testedClass.CreateFeature();
testedRow.Shape =
CurveConstruction.StartLine(201, 150)
.LineTo(201, 50)
.Curve;
testedRow.Store();
IFeature referenceRow = referenceClass.CreateFeature();
referenceRow.Shape =
CurveConstruction.StartLine(199, 150)
.LineTo(199, 50)
.Curve;
referenceRow.Store();
IEnvelope verificationEnvelope =
GeometryFactory.CreateEnvelope(0, 0, 500, 500);
var test = new QaPartCoincidenceOther(testedClass, referenceClass, 3, 50);
var runner = new QaContainerTestRunner(200, test);
runner.Execute(verificationEnvelope);
AssertUtils.OneError(runner,
"NearCoincidence.NearlyCoincidentSection.BetweenFeatures");
}
public void CanReportVertexInLeftTileByNearDistance()
{
const string testName = "CanReportVertexInLeftTileByNearDistance";
IFeatureClass nodeClass = CreateFeatureClass(string.Format("{0}_node", testName),
esriGeometryType.esriGeometryPoint);
IFeatureClass nearClass = CreateFeatureClass(string.Format("{0}_near", testName),
esriGeometryType.esriGeometryPolyline);
var nearClasses = new List <IFeatureClass> {
nearClass
};
IFeature nodeRow = nodeClass.CreateFeature();
nodeRow.Shape = GeometryFactory.CreatePoint(201, 100);
nodeRow.Store();
IFeature nearRow = nearClass.CreateFeature();
nearRow.Shape = CurveConstruction.StartLine(100, 100)
.LineTo(100, 199)
.LineTo(199, 199)
.LineTo(199, 100)
.Curve;
nearRow.Store();
IEnvelope verificationEnvelope = GeometryFactory.CreateEnvelope(0, 0, 500, 500);
var test = new QaNodeLineCoincidence(nodeClass, nearClasses, 2.1);
var runner = new QaContainerTestRunner(200, test);
runner.Execute(verificationEnvelope);
AssertUtils.OneError(runner,
"NodeLineCoincidence.NodeTooCloseToLine.BetweenFeatures");
}
public void CanDetectTooFewRowsWithReferenceTables()
{
var verified = new FeatureClassMock(1, "v", _gt)
{
RowCountResult = 999
};
var r1 = new FeatureClassMock(2, "r1", _gt)
{
RowCountResult = 400
};
var r2 = new FeatureClassMock(3, "r2", _gt)
{
RowCountResult = 600
};
var test = new QaRowCount(verified, new ITable[] { r1, r2 }, "0", "0");
var runner = new QaTestRunner(test);
runner.Execute();
AssertUtils.OneError(runner, "RowCount.TooFewRows");
}
public void CanReportMultipartFootPrintTouchingInPoint()
{
FeatureClassMock featureClassMock = CreateFeatureClassMock();
var construction = new MultiPatchConstruction();
construction.StartOuterRing(0, 0, 0)
.Add(10, 0, 0)
.Add(10, 10, 0)
.Add(0, 10, 0)
.StartOuterRing(10, 10, 0)
.Add(20, 10, 0)
.Add(20, 20, 0)
.Add(10, 20, 0);
IFeature row = featureClassMock.CreateFeature(construction.MultiPatch);
var test = new QaMpSinglePartFootprint(featureClassMock);
var runner = new QaTestRunner(test);
runner.Execute(row);
AssertUtils.OneError(runner, "MpSinglePartFootprint.FootprintHasMultipleParts");
}
public void CanTestPolylineFeature()
{
IFeatureClass fc = new FeatureClassMock(1, "LineFc",
esriGeometryType.esriGeometryPolyline);
IFeature feature = fc.CreateFeature();
feature.Shape = CurveConstruction.StartLine(0, 0)
.LineTo(10, 10)
.CircleTo(30, 10)
.Curve;
feature.Store();
var test = new QaGeometryConstraint(fc, "$CircularArcCount = 0", perPart: false);
var runner = new QaTestRunner(test);
runner.Execute(feature);
QaError error;
AssertUtils.OneError(runner, "GeometryConstraint.ConstraintNotFulfilled.ForShape",
out error);
Assert.True(GeometryUtils.AreEqual(feature.Shape, error.Geometry));
}
