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");
}
public void TestAllowedCoordinatesForUndefinedShape()
{
var featureClass = new FeatureClassMock(1, "Fc", esriGeometryType.esriGeometryPoint);
featureClass.AddField(FieldUtils.CreateDoubleField(_fieldNameX));
featureClass.AddField(FieldUtils.CreateDoubleField(_fieldNameY));
featureClass.AddField(FieldUtils.CreateDoubleField(_fieldNameZ));
// create point feature
const double x = 2600000;
const double y = 1200000;
const double z = 500;
IFeature feature = CreateFeature(featureClass,
x, x,
y, y,
z, z);
feature.Shape.SetEmpty();
var test = new QaValidCoordinateFields(featureClass,
_fieldNameX, _fieldNameY, _fieldNameZ,
_xyTolerance, _zTolerance, _culture)
{
AllowXYFieldValuesForUndefinedShape = true,
AllowZFieldValueForUndefinedShape = true
};
var runner = new QaTestRunner(test);
runner.Execute(feature);
Assert.AreEqual(0, runner.Errors.Count);
}
public void TestEqualCoordinatesTextFields()
{
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;
const double z = 500.12345;
IFeature feature = CreateFeature(
featureClass,
x, string.Format(_cultureInfo, "{0:N3}", x),
y, string.Format(_cultureInfo, "{0:N3}", y),
z, string.Format(_cultureInfo, "{0:N3}", z));
var test = new QaValidCoordinateFields(featureClass,
_fieldNameX, _fieldNameY, _fieldNameZ,
_xyTolerance, _zTolerance, _culture);
var runner = new QaTestRunner(test);
runner.Execute(feature);
Assert.AreEqual(0, runner.Errors.Count);
}
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 TestNonEqualCoordinatesTextFieldsEqualY()
{
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;
const double z = 500.12345;
IFeature feature = CreateFeature(
featureClass,
x, string.Format(_cultureInfo, "{0:N3}", x + 1.01 * _xyTolerance),
y, string.Format(_cultureInfo, "{0:N3}", y),
z, string.Format(_cultureInfo, "{0:N3}", z + 1.01 * _zTolerance));
var test = new QaValidCoordinateFields(featureClass,
_fieldNameX, _fieldNameY, _fieldNameZ,
_xyTolerance, _zTolerance, _culture);
var runner = new QaTestRunner(test);
runner.Execute(feature);
Assert.AreEqual(2, runner.Errors.Count);
QaError xyError = runner.Errors[0];
IssueCode xyIssueCode = xyError.IssueCode;
Assert.IsNotNull(xyIssueCode);
Assert.AreEqual("ValidCoordinateFields.XYFieldCoordinateValueTooFarFromShape",
xyIssueCode.ID);
QaError zError = runner.Errors[1];
IssueCode zIssueCode = zError.IssueCode;
Assert.IsNotNull(zIssueCode);
Assert.AreEqual("ValidCoordinateFields.ZFieldCoordinateTooFarFromShape",
zIssueCode.ID);
}
public void TestMissingXYCoordinatesForDefinedShape()
{
var featureClass = new FeatureClassMock(1, "Fc", esriGeometryType.esriGeometryPoint);
featureClass.AddField(FieldUtils.CreateDoubleField(_fieldNameX));
featureClass.AddField(FieldUtils.CreateDoubleField(_fieldNameY));
featureClass.AddField(FieldUtils.CreateDoubleField(_fieldNameZ));
// create point feature
const double x = 2600000;
const double y = 1200000;
const double z = 500;
IFeature feature = CreateFeature(featureClass,
x, null,
y, null,
z, z);
var test = new QaValidCoordinateFields(featureClass,
_fieldNameX, _fieldNameY, _fieldNameZ,
_xyTolerance, _zTolerance, _culture)
{
AllowMissingXYFieldValueForDefinedShape = false,
AllowMissingZFieldValueForDefinedShape = false
};
var runner = new QaTestRunner(test);
runner.Execute(feature);
Assert.AreEqual(2, runner.Errors.Count);
foreach (QaError error in runner.Errors)
{
IssueCode issueCode = error.IssueCode;
Assert.IsNotNull(issueCode);
Assert.AreEqual(
"ValidCoordinateFields.ShapeIsDefinedButCoordinateFieldHasNoValue",
issueCode.ID);
}
Assert.AreEqual(_fieldNameX, runner.Errors[0].AffectedComponent);
Assert.AreEqual(_fieldNameY, runner.Errors[1].AffectedComponent);
}
public void TestInvalidTextFieldValues()
{
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;
const double z = 500.12345;
IFeature feature = CreateFeature(featureClass,
x, "a",
y, "b",
z, "c");
var test = new QaValidCoordinateFields(featureClass,
_fieldNameX, _fieldNameY, _fieldNameZ,
_xyTolerance, _zTolerance, _culture);
var runner = new QaTestRunner(test);
runner.Execute(feature);
Assert.AreEqual(3, runner.Errors.Count);
foreach (QaError error in runner.Errors)
{
IssueCode issueCode = error.IssueCode;
Assert.IsNotNull(issueCode);
Assert.AreEqual("ValidCoordinateFields.TextFieldValueIsNotNumeric",
issueCode.ID);
}
Assert.AreEqual(_fieldNameX, runner.Errors[0].AffectedComponent);
Assert.AreEqual(_fieldNameY, runner.Errors[1].AffectedComponent);
Assert.AreEqual(_fieldNameZ, runner.Errors[2].AffectedComponent);
}
public void CanTestConstraint()
{
ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference(
WellKnownHorizontalCS.LV95);
var multiPatchClass = new FeatureClassMock(
1, "multipatch", esriGeometryType.esriGeometryMultiPatch,
esriFeatureType.esriFTSimple, sref);
multiPatchClass.AddField("Level", esriFieldType.esriFieldTypeInteger);
int levelIndex = multiPatchClass.FindField("Level");
var polygonClass = new FeatureClassMock(
1, "polygon", esriGeometryType.esriGeometryPolygon,
esriFeatureType.esriFTSimple, sref);
polygonClass.AddField("Level", esriFieldType.esriFieldTypeInteger);
var multiPatchConstruction = new MultiPatchConstruction();
multiPatchConstruction.StartOuterRing(0, 0, 0)
.Add(5, 0, 0)
.Add(5, 1, 5)
.Add(0, 1, 5);
IFeature multiPatchRow =
multiPatchClass.CreateFeature(multiPatchConstruction.MultiPatch);
multiPatchRow.set_Value(levelIndex, 2);
CurveConstruction curveConstruction =
CurveConstruction.StartPoly(0, 0, 50)
.LineTo(10, 0, 50)
.LineTo(0, 10, 50);
IFeature polygonRow =
polygonClass.CreateFeature(curveConstruction.ClosePolygon());
polygonRow.set_Value(levelIndex, 1);
var test = new QaZDifferenceSelfWrapper(
new[] { (IFeatureClass)multiPatchClass, polygonClass },
20, 0,
ZComparisonMethod.BoundingBox,
"U.Level > L.Level");
var runner = new QaTestRunner(test);
int errorCount = test.TestDirect(multiPatchRow, 0, polygonRow, 1);
Assert.AreEqual(1, errorCount);
Assert.AreEqual(1, runner.Errors.Count);
}
public void CanFormatRowWithFieldNameContainedInOtherField()
{
// TOP-5056: Field PLZ_ZZ and PLZ are both present in the feature class:
const string name = "TESTCLASS";
const string aliasName = "Test FeatureClass";
var featureClassMock = new FeatureClassMock(
1, name, aliasName, esriGeometryType.esriGeometryPolyline);
featureClassMock.AddField("NAME", esriFieldType.esriFieldTypeString);
featureClassMock.AddField("PLZ", esriFieldType.esriFieldTypeInteger);
featureClassMock.AddField("PLZ_ZZ", esriFieldType.esriFieldTypeInteger);
IFeature feature = featureClassMock.CreateFeature();
var plz = 5023;
var zz = 2;
feature.Value[feature.Fields.FindField("PLZ")] = plz;
feature.Value[feature.Fields.FindField("PLZ_ZZ")] = zz;
Assert.AreEqual($"{plz}_{zz}", RowFormat.Format(@"{PLZ}_{PLZ_ZZ}", feature));
}
public void CanFormatRow()
{
const string name = "TESTCLASS";
const string aliasName = "Test FeatureClass";
var featureClassMock = new FeatureClassMock(
1, name, aliasName, esriGeometryType.esriGeometryPolyline);
featureClassMock.AddField("NAME", esriFieldType.esriFieldTypeString);
featureClassMock.AddField("PLZ", esriFieldType.esriFieldTypeInteger);
IFeature feature = featureClassMock.CreateFeature();
Assert.AreEqual($"{feature.OID}", RowFormat.Format(feature));
Assert.AreEqual($"{aliasName} - {feature.OID}", RowFormat.Format(feature, true));
var plz = 5023;
feature.Value[feature.Fields.FindField("PLZ")] = plz;
Assert.AreEqual($": {plz}", RowFormat.Format(@"{NAME}: {PLZ}", feature));
Assert.AreEqual($"<null>: {plz}",
RowFormat.Format(@"{NAME}: {PLZ}", feature, "<null>"));
}
