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 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);
}
private static IEnumerable <IField> CreateFields()
{
yield return(FieldUtils.CreateOIDField());
yield return(FieldUtils.CreateDoubleField(_doubleFieldName));
yield return(FieldUtils.CreateDateField(_dateFieldName));
yield return(FieldUtils.CreateTextField(_textFieldName, 500));
yield return(FieldUtils.CreateTextField(_stateFieldName, 2));
}
private IFeatureClass CreateFeatureClass(string name, esriGeometryType geometryType)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateShapeField(
"Shape", geometryType, _spatialReference, 1000));
fields.AddField(FieldUtils.CreateTextField(_stateIdFieldName, 100));
fields.AddField(FieldUtils.CreateTextField(_textFieldName, 200));
fields.AddField(FieldUtils.CreateDoubleField(_doubleFieldName));
fields.AddField(FieldUtils.CreateDateField(_dateFieldName));
return(DatasetUtils.CreateSimpleFeatureClass(
_featureWorkspace, name, fields));
}
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 CanCreateDoubleCodedValueDomainConstraint()
{
ICodedValueDomain doubleCvDomain = DomainUtils.CreateCodedValueDomain(
"CanCreateDoubleCodedValueDomainConstraint",
esriFieldType.esriFieldTypeDouble, null,
esriSplitPolicyType.esriSPTDuplicate,
esriMergePolicyType.esriMPTDefaultValue,
new CodedValue(1.00000000001, "Value 1.00000000001"),
new CodedValue(2.00000000002, "Value 2.00000000002"),
new CodedValue(3.00000000003, "Value 3.00000000003"));
DomainUtils.AddDomain(_testWs, doubleCvDomain);
IField doubleField = FieldUtils.CreateDoubleField("DoubleField");
((IFieldEdit)doubleField).Domain_2 = (IDomain)doubleCvDomain;
ITable table = DatasetUtils.CreateTable(_testWs,
"CanCreateDoubleCodedValueDomainConstraint",
FieldUtils.CreateOIDField(),
doubleField);
List <ConstraintNode> constraints =
GdbConstraintUtils.GetGdbConstraints(table);
Assert.NotNull(constraints);
foreach (ConstraintNode constraint in constraints)
{
Console.WriteLine(constraint);
}
Assert.AreEqual(2, constraints.Count);
Assert.AreEqual(
"DoubleField IS NULL OR (Convert(DoubleField, 'System.Single') IN " +
"(Convert(1.00000000001, 'System.Single'), " +
"Convert(2.00000000002, 'System.Single'), " +
"Convert(3.00000000003, 'System.Single')))",
constraints[0].Condition);
Assert.AreEqual("OBJECTID >= 0", constraints[1].Condition);
}
private IEnumerable <IField> GetFields([NotNull] ISpatialReference spatialReference,
bool hasZ = false,
bool hasM = false)
{
yield return(FieldUtils.CreateShapeField(esriGeometryType.esriGeometryPolygon,
spatialReference,
hasZ: hasZ,
hasM: hasM));
yield return
(FieldUtils.CreateTextField(_fieldNames[AttributeRole.Description], 2000));
yield return
(FieldUtils.CreateTextField(_fieldNames[AttributeRole.FeatureSource], 500));
yield return
(FieldUtils.CreateTextField(_fieldNames[AttributeRole.WhereClause], 2000));
yield return
(FieldUtils.CreateDoubleField(_fieldNames[AttributeRole.BufferDistance]));
yield return
(FieldUtils.CreateDoubleField(_fieldNames[AttributeRole.GeneralizationTolerance]));
}
public void CanTestPointNotNearPolylineRightSide()
{
IFeatureWorkspace testWs =
TestWorkspaceUtils.CreateInMemoryWorkspace(
"CanTestPointNotNearPolylineRightSide");
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateDoubleField("minDistance"));
fields.AddField(FieldUtils.CreateDoubleField("rightSideDistance"));
fields.AddField(FieldUtils.CreateIntegerField("flip"));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, true));
IFeatureClass polyFc = DatasetUtils.CreateSimpleFeatureClass(
testWs, "polylineFc",
fields);
IFeatureClass pointFc = CreatePointClass(testWs, "pointFc");
IFeature polyFeature = polyFc.CreateFeature();
polyFeature.set_Value(1, 5);
polyFeature.set_Value(2, 10);
polyFeature.set_Value(3, 1);
polyFeature.Shape = CurveConstruction.StartLine(0, 0, 0)
.LineTo(100, 0, 10)
.LineTo(100, 100, 10)
.Curve;
polyFeature.Store();
IFeature p1 = pointFc.CreateFeature();
p1.Shape = GeometryFactory.CreatePoint(10, 7, 0);
p1.Store();
IFeature p2 = pointFc.CreateFeature();
p2.Shape = GeometryFactory.CreatePoint(-0.1, 7, 0);
p2.Store();
IFeature p3 = pointFc.CreateFeature();
p3.Shape = GeometryFactory.CreatePoint(93, 100.1, 10);
p3.Store();
//QaPointNotNear.UseQueryPointAndDistance = true;
var test1 = new QaPointNotNear(pointFc, polyFc, 10.0);
var runner = new QaContainerTestRunner(1000, test1);
runner.Execute();
Assert.AreEqual(3, runner.Errors.Count);
var test2 = new QaPointNotNear(pointFc, new[] { polyFc }, 10.0, null,
new[] { "minDistance" });
runner = new QaContainerTestRunner(1000, test2);
runner.Execute();
Assert.AreEqual(0, runner.Errors.Count);
var test3 = new QaPointNotNear(pointFc, new[] { polyFc }, 10, null, new[] { "5" },
new[] { "rightSideDistance" },
null);
runner = new QaContainerTestRunner(1000, test3);
runner.Execute();
Assert.AreEqual(0, runner.Errors.Count);
var test4 = new QaPointNotNear(pointFc, new[] { polyFc }, 10, null,
new[] { "5" },
new[] { "rightSideDistance" },
new[] { "true" });
runner = new QaContainerTestRunner(1000, test4);
runner.Execute();
Assert.AreEqual(3, runner.Errors.Count);
var test5 = new QaPointNotNear(pointFc, new[] { polyFc }, 10, null,
new[] { "5" },
new[] { "rightSideDistance" },
new[] { "flip > 0" });
runner = new QaContainerTestRunner(1000, test5);
runner.Execute();
Assert.AreEqual(3, runner.Errors.Count);
}
private static void TestInvalidArguments(IFeatureWorkspace ws)
{
ISpatialReference sr = SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95, true);
ISpatialReference srM = SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95, true);
SpatialReferenceUtils.SetMDomain(srM, 0, 1000000, 0.001, 0.002);
IFieldsEdit fieldsPoint = new FieldsClass();
fieldsPoint.AddField(FieldUtils.CreateOIDField());
fieldsPoint.AddField(FieldUtils.CreateDoubleField("DoubleField"));
fieldsPoint.AddField(FieldUtils.CreateIntegerField("IntField"));
fieldsPoint.AddField(FieldUtils.CreateTextField("StringField", 50));
fieldsPoint.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPoint, sr, 1000));
IFeatureClass fcPoints =
DatasetUtils.CreateSimpleFeatureClass(ws, "InvalidArgumentsPoints", fieldsPoint);
IFieldsEdit fieldsLine = new FieldsClass();
fieldsLine.AddField(FieldUtils.CreateOIDField());
fieldsLine.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline, sr, 1000));
IFeatureClass fcLines =
DatasetUtils.CreateSimpleFeatureClass(ws, "InvalidArgumentsLines", fieldsLine);
IFieldsEdit fieldsLineM = new FieldsClass();
fieldsLineM.AddField(FieldUtils.CreateOIDField());
fieldsLineM.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline, srM, 1000,
false, true));
IFeatureClass fcLinesM =
DatasetUtils.CreateSimpleFeatureClass(ws, "InvalidArgumentsLinesM", fieldsLineM);
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
var success = true;
try
{
var test = new QaMeasuresAtPoints(fcPoints, null, new[] { fcLines }, 0.01, 0.01,
LineMSource.Nearest, false);
Assert.IsNotNull(test);
}
catch (ArgumentException)
{
success = false;
}
Assert.IsFalse(success);
success = true;
try
{
var test = new QaMeasuresAtPoints(fcPoints, null, new[] { fcLinesM }, 0.01, 0.01,
LineMSource.Nearest, false);
Assert.IsNotNull(test);
}
catch (ArgumentException)
{
success = false;
}
Assert.IsFalse(success);
success = true;
try
{
var test = new QaMeasuresAtPoints(fcPoints, "UnknownField", new[] { fcLinesM },
0.01, 0.01, LineMSource.Nearest, false);
Assert.IsNotNull(test);
}
catch (EvaluateException)
{
success = false;
}
Assert.IsFalse(success);
}
private static void TestWithErrors(IFeatureWorkspace ws)
{
ISpatialReference srM = SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95, true);
SpatialReferenceUtils.SetMDomain(srM, 0, 1000000, 0.001, 0.002);
IFieldsEdit fieldsPoint = new FieldsClass();
fieldsPoint.AddField(FieldUtils.CreateOIDField());
fieldsPoint.AddField(FieldUtils.CreateDoubleField("DoubleField"));
fieldsPoint.AddField(FieldUtils.CreateIntegerField("IntField"));
fieldsPoint.AddField(FieldUtils.CreateTextField("StringField", 50));
fieldsPoint.AddField(FieldUtils.CreateDoubleField("EmptyField"));
fieldsPoint.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPoint, srM, 1000, false,
true));
IFeatureClass fcPoints =
DatasetUtils.CreateSimpleFeatureClass(ws, "WithErrorsPoints", fieldsPoint);
IFieldsEdit fieldsLine = new FieldsClass();
fieldsLine.AddField(FieldUtils.CreateOIDField());
fieldsLine.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline, srM, 1000,
false, true));
IFeatureClass fcLines =
DatasetUtils.CreateSimpleFeatureClass(ws, "WithErrorsLines", fieldsLine);
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
IFeature point1 = fcPoints.CreateFeature();
point1.set_Value(1, 2); // DoubleField
point1.set_Value(2, 2); // IntField
point1.set_Value(3, "A"); // StringField
point1.Shape = CreatePoint(100, 100, 2);
point1.Store();
IFeature fLine1 = fcLines.CreateFeature();
IPolycurve l1 =
CurveConstruction.StartLine(CreatePoint(100, 100, 1))
.LineTo(CreatePoint(200, 200, 1))
.Curve;
((IMAware)l1).MAware = true;
fLine1.Shape = l1;
fLine1.Store();
var test = new QaMeasuresAtPoints(fcPoints, null, new[] { fcLines }, 0.01, 0.01,
LineMSource.Nearest, false);
var container = new QaContainerTestRunner(10000, test);
container.Execute();
Assert.AreEqual(1, container.Errors.Count);
test = new QaMeasuresAtPoints(fcPoints, "DoubleField", new[] { fcLines }, 0.01,
0.01, LineMSource.Nearest, false);
container = new QaContainerTestRunner(10000, test);
container.Execute();
Assert.AreEqual(1, container.Errors.Count);
test = new QaMeasuresAtPoints(fcPoints, "IntField", new[] { fcLines }, 0.01, 0.01,
LineMSource.Nearest, false);
container = new QaContainerTestRunner(10000, test);
container.Execute();
Assert.AreEqual(1, container.Errors.Count);
test = new QaMeasuresAtPoints(fcPoints, "EmptyField", new[] { fcLines }, 0.01, 0.01,
LineMSource.Nearest, false);
container = new QaContainerTestRunner(10000, test);
container.Execute();
Assert.AreEqual(1, container.Errors.Count);
test = new QaMeasuresAtPoints(fcPoints, "0.5 * EmptyField", new[] { fcLines }, 0.01,
0.01, LineMSource.Nearest, false);
container = new QaContainerTestRunner(10000, test);
container.Execute();
Assert.AreEqual(1, container.Errors.Count);
}
public void TestExpression()
{
const string intField = "Int";
const string doubleField = "Dbl";
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateIntegerField(intField));
fields.AddField(FieldUtils.CreateDoubleField(doubleField, doubleField));
ITable tbl = DatasetUtils.CreateTable(_testWs, "TestExpression", null, fields);
const int n = 10;
for (var i = 0; i < n; i++)
{
IRow row = tbl.CreateRow();
row.set_Value(1, i);
row.set_Value(2, i);
row.Store();
}
const double x = 2;
string expression = string.Format("{0}, {1}, {2}", x, intField, doubleField);
const bool useAsConstraint = false;
TableView view = TableViewFactory.Create(tbl, expression, useAsConstraint);
DataColumn constColumn = view.AddColumn("constValue", typeof(double));
constColumn.Expression = x.ToString(CultureInfo.InvariantCulture);
DataColumn intColumn = view.AddColumn("intValue", typeof(double));
intColumn.Expression = intField;
DataColumn exprColumn = view.AddColumn("exprValue", typeof(double));
exprColumn.Expression = string.Format("2.3 * {0} + 1.2 * {1}", doubleField,
intField);
DataColumn doubleColumn = view.AddColumn("doubleValue", typeof(double));
doubleColumn.Expression = doubleField;
foreach (IRow row in new EnumCursor(tbl, null, false))
{
view.ClearRows();
var i = (int)row.Value[1];
var d = (double)row.Value[2];
DataRow expressionRow = Assert.NotNull(view.Add(row));
var constVal = (double)expressionRow[constColumn.ColumnName];
NUnit.Framework.Assert.AreEqual(x, constVal);
var intVal = (double)expressionRow[intColumn.ColumnName];
NUnit.Framework.Assert.AreEqual(i, intVal);
var doubleVal = (double)expressionRow[doubleColumn.ColumnName];
NUnit.Framework.Assert.AreEqual(d, doubleVal);
var exprVal = (double)expressionRow[exprColumn.ColumnName];
NUnit.Framework.Assert.AreEqual(2.3 * d + 1.2 * i, exprVal);
}
}
