private static void TestNotReferenced(IFeatureWorkspace ws)
{
IFieldsEdit fields1 = new FieldsClass();
fields1.AddField(FieldUtils.CreateOIDField());
fields1.AddField(FieldUtils.CreateSmallIntegerField("Pk"));
ITable tbl1 = DatasetUtils.CreateTable(ws, "TestNotReferenced1", null, fields1);
IFieldsEdit fields2 = new FieldsClass();
fields2.AddField(FieldUtils.CreateOIDField());
fields2.AddField(FieldUtils.CreateIntegerField("Fk"));
ITable tbl2 = DatasetUtils.CreateTable(ws, "TestNotReferenced2", null, fields2);
IFieldsEdit fields3 = new FieldsClass();
fields3.AddField(FieldUtils.CreateOIDField());
fields3.AddField(FieldUtils.CreateIntegerField("Fk"));
ITable tbl3 = DatasetUtils.CreateTable(ws, "TestNotReferenced3", null, fields3);
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
CreateRow(tbl1, 1);
CreateRow(tbl1, 2);
CreateRow(tbl1, 3);
CreateRow(tbl1, 4);
CreateRow(tbl1, 5);
CreateRow(tbl2, 1);
//CreateRow(tbl2, 3);
CreateRow(tbl2, 5);
CreateRow(tbl3, 2);
CreateRow(tbl3, 4);
var test = new QaUnreferencedRows(tbl1,
new[] { tbl2, tbl3 },
new[] { "pk,fk", "pk,fk" });
using (var r = new QaTestRunner(test))
{
r.Execute();
Assert.AreEqual(1, r.Errors.Count);
}
var container = new QaContainerTestRunner(10000, test);
container.Execute();
Assert.AreEqual(1, container.Errors.Count);
}
private static void TestConditionCoincidence(IFeatureWorkspace ws)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateIntegerField("LandId"));
fields.AddField(FieldUtils.CreateIntegerField("OtherId"));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, false, false));
IFeatureClass fc1 =
DatasetUtils.CreateSimpleFeatureClass(ws, "TestConditionCoincidence1",
fields,
null);
IFeatureClass fc2 =
DatasetUtils.CreateSimpleFeatureClass(ws, "TestConditionCoincidence2",
fields,
null);
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
{
IFeature row = fc1.CreateFeature();
row.set_Value(1, 1);
row.Shape = CurveConstruction.StartLine(100, 100).LineTo(200, 200).Curve;
row.Store();
}
{
IFeature row = fc2.CreateFeature();
row.set_Value(1, 1);
row.Shape = CurveConstruction
.StartLine(100.5, 100).LineTo(200.5, 200).Curve;
row.Store();
}
// test without ignore conditions --> line is near, but not coincident
var test = new QaPartCoincidenceOther(fc1, fc2, 1, 10);
var testRunner = new QaTestRunner(test);
testRunner.Execute();
Assert.AreEqual(1, testRunner.Errors.Count);
// Same test with ignore conditions --> nothing near
test = new QaPartCoincidenceOther(fc1, fc2, 1, 10);
test.IgnoreNeighborCondition = "G1.LandID = G2.LandID";
testRunner = new QaTestRunner(test);
testRunner.Execute();
Assert.AreEqual(0, testRunner.Errors.Count);
}
private static void TestNMRelation(IFeatureWorkspace ws)
{
IFieldsEdit fields1 = new FieldsClass();
fields1.AddField(FieldUtils.CreateOIDField());
fields1.AddField(FieldUtils.CreateIntegerField("Pk"));
ITable tbl1 = DatasetUtils.CreateTable(ws, "TestNMRelation1", null, fields1);
IFieldsEdit fields2 = new FieldsClass();
fields2.AddField(FieldUtils.CreateOIDField());
fields2.AddField(FieldUtils.CreateIntegerField("Fk"));
ITable tbl2 = DatasetUtils.CreateTable(ws, "TestNMRelation2", null, fields2);
IRelationshipClass rel = CreateSimpleMNRelationship(ws, "TestNMRelationRel", tbl1,
tbl2, "Pk", "Fk");
((IWorkspaceEdit)ws).StartEditing(false);
IRow r11 = CreateRow(tbl1, 8);
IRow r12 = CreateRow(tbl1, 12);
IRow r13 = CreateRow(tbl1, 7);
IRow r21 = CreateRow(tbl2, 9);
IRow r22 = CreateRow(tbl2, 5);
IRow r23 = CreateRow(tbl2, 4);
Assert.NotNull(r12); // not used otherwise
rel.CreateRelationship((IObject)r11, (IObject)r21);
rel.CreateRelationship((IObject)r11, (IObject)r23);
rel.CreateRelationship((IObject)r13, (IObject)r22);
r22.set_Value(1, 6);
r22.Store();
((IWorkspaceEdit)ws).StopEditing(true);
var test = new QaUnreferencedRows(tbl1,
new[] { tbl2 },
new[] { "pk,pk,TestNMRelationRel,fk,fk" });
using (var r = new QaTestRunner(test))
{
r.Execute();
Assert.AreEqual(2, r.Errors.Count);
}
var container = new QaContainerTestRunner(10000, test);
container.Execute();
Assert.AreEqual(2, container.Errors.Count);
}
public void CanUseMMinMaxAliasInMultiTableView()
{
IFeatureClass featureClass = CreateFeatureClass(
"CanUseMMinMaxAliasInMultiTableView",
esriGeometryType.esriGeometryPolyline,
zAware: true, mAware: true);
ITable table = CreateTable("CanUseMMinMaxAliasInMultiTableView_table",
FieldUtils.CreateOIDField(),
FieldUtils.CreateIntegerField("NUMBER"));
IFeature f1 = featureClass.CreateFeature();
f1.Shape = GeometryFactory.CreatePolyline(
GeometryFactory.CreatePoint(0, 0, 1000, 100),
GeometryFactory.CreatePoint(5, 5, 1000, 200));
f1.Store();
IFeature f2 = featureClass.CreateFeature();
f2.Shape = GeometryFactory.CreatePolyline(
GeometryFactory.CreatePoint(0, 0, 1000, 300),
GeometryFactory.CreatePoint(5, 5, 1000, 400));
f2.Store();
int fieldIndexNumber = table.FindField("NUMBER");
IRow r1 = table.CreateRow();
r1.Value[fieldIndexNumber] = 100;
r1.Store();
IRow r2 = table.CreateRow();
r2.Value[fieldIndexNumber] = 200;
r2.Store();
AssertFilteredMultiViewRowCount(1,
"F.$ShapeMMin = 100 AND F.$ShapeMMax = 200 AND T.NUMBER = 100",
featureClass, f1, table, r1);
AssertFilteredMultiViewRowCount(0,
"F.$ShapeMMin = 100 AND F.$ShapeMMax = 200 AND T.NUMBER = 10000",
featureClass, f1, table, r1);
AssertFilteredMultiViewRowCount(1,
"F.$ShapeMMin = 300 AND F.$ShapeMMax = 400 AND T.NUMBER = 200",
featureClass, f2, table, r2);
AssertFilteredMultiViewRowCount(0,
"F.$ShapeMMin = 300 AND F.$ShapeMMax = 400 AND T.NUMBER = 10000",
featureClass, f2, table, r2);
}
public void TestMultipart()
{
IFeatureWorkspace ws = TestWorkspaceUtils.CreateInMemoryWorkspace("Testmultipart");
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateIntegerField("LineTyp", "LineTyp"));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, false, false));
IFeatureClass fc =
DatasetUtils.CreateSimpleFeatureClass(ws, "TestConnections", fields,
null);
IList <ITable> tbls = new[] { (ITable)fc };
{
IFeature row = fc.CreateFeature();
row.set_Value(1, 1);
row.Shape =
CurveConstruction.StartLine(1, 1).LineTo(2, 2).MoveTo(3, 2).LineTo(4, 2).Curve;
row.Store();
}
{
IFeature row = fc.CreateFeature();
row.set_Value(1, 2);
row.Shape =
CurveConstruction.StartLine(1, 5).LineTo(2, 2).Curve;
row.Store();
}
IList <QaConnectionRule> rules = new List <QaConnectionRule>
{
new QaConnectionRule(tbls, new[] { "LineTyp = 1" }),
new QaConnectionRule(tbls, new[] { "LineTyp = 2" })
};
var test = new QaConnections(new[] { fc }, rules, 0);
test.UseMultiParts = false;
var runner = new QaContainerTestRunner(1000, test);
Assert.AreEqual(0, runner.Execute());
test.UseMultiParts = true;
runner = new QaContainerTestRunner(1000, test);
Assert.AreEqual(1, runner.Execute());
}
public void CanFindDanglingSimpleKey()
{
const string key = "KEY1";
const string fkey = "FKEY1";
ITable referencedTable = DatasetUtils.CreateTable(
_workspace,
string.Format("{0}_key", MethodBase.GetCurrentMethod().Name),
FieldUtils.CreateOIDField(),
FieldUtils.CreateIntegerField(key));
ITable referencingTable = DatasetUtils.CreateTable(
_workspace,
string.Format("{0}_fkey", MethodBase.GetCurrentMethod().Name),
FieldUtils.CreateOIDField(),
FieldUtils.CreateTextField(fkey, 10));
GdbObjectUtils.CreateRow(referencedTable,
new Dictionary <string, object> {
{ key, 1000 }
}).Store();
GdbObjectUtils.CreateRow(referencedTable,
new Dictionary <string, object> {
{ key, 2000 }
}).Store();
GdbObjectUtils.CreateRow(referencingTable,
new Dictionary <string, object> {
{ fkey, "1000" }
}).Store();
GdbObjectUtils.CreateRow(referencingTable,
new Dictionary <string, object> {
{ fkey, "2000" }
}).Store();
// dangling reference:
GdbObjectUtils.CreateRow(referencingTable,
new Dictionary <string, object> {
{ fkey, "3000" }
}).Store();
var runner = new QaTestRunner(
new QaForeignKey(referencingTable, fkey, referencedTable, key));
runner.Execute();
Assert.AreEqual(1, runner.Errors.Count);
}
public void CanUseObjectIdAliasInMultiTableView()
{
IFeatureClass featureClass = CreateFeatureClass(
"CanUseObjectIdAliasInMultiTableView",
esriGeometryType.esriGeometryPoint);
ITable table = CreateTable("CanUseObjectIdAliasInMultiTableView_table",
FieldUtils.CreateOIDField(),
FieldUtils.CreateIntegerField("NUMBER"));
IFeature f1 = featureClass.CreateFeature();
f1.Shape = GeometryFactory.CreatePoint(0, 0);
f1.Store();
IFeature f2 = featureClass.CreateFeature();
f2.Shape = GeometryFactory.CreatePoint(5, 5);
f2.Store();
int fieldIndexNumber = table.FindField("NUMBER");
IRow r1 = table.CreateRow();
r1.Value[fieldIndexNumber] = 100;
r1.Store();
IRow r2 = table.CreateRow();
r2.Value[fieldIndexNumber] = 200;
r2.Store();
AssertFilteredMultiViewRowCount(1,
"F.$ObjectId = 1 AND T.$ObjectId = 1 AND T.NUMBER = 100",
featureClass, f1, table, r1);
AssertFilteredMultiViewRowCount(0,
"F.$ObjectId = 1 AND T.$ObjectId = 1 AND T.NUMBER = 10000",
featureClass, f1, table, r1);
AssertFilteredMultiViewRowCount(1,
"F.$ObjectId = 2 AND T.$ObjectId = 2 AND T.NUMBER = 200",
featureClass, f2, table, r2);
AssertFilteredMultiViewRowCount(0,
"F.$ObjectId = 2 AND T.$ObjectId = 2 AND T.NUMBER = 10000",
featureClass, f2, table, r2);
}
public void TestExcludedFields()
{
IFeatureWorkspace initTestWs = _testWs;
try
{
_testWs = TestWorkspaceUtils.CreateInMemoryWorkspace("QaRegularExpression");
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateIntegerField(_fkFieldName));
fields.AddField(FieldUtils.CreateTextField(_textFieldName, 200));
fields.AddField(FieldUtils.CreateTextField(_textFieldName2, 200));
const string tableName = "RegEx_table_excluded";
ITable table =
TestWorkspaceUtils.CreateSimpleTable(_testWs, tableName, fields);
((IWorkspaceEdit)_testWs).StartEditing(false);
AddRow(table, textFieldValue: "A", textFieldValue2: "X");
AddRow(table, textFieldValue: "B", textFieldValue2: "X");
AddRow(table, textFieldValue: "A", textFieldValue2: "X");
((IWorkspaceEdit)_testWs).StopEditing(true);
var test =
new QaRegularExpression(table, "A", _textFieldName2)
{
FieldListType = FieldListType.IgnoredFields
};
IList <QaError> errors = Run(test, 1000);
AssertErrors(1, errors);
IList <InvolvedRow> involvedRows = errors[0].InvolvedRows;
Assert.AreEqual(1, involvedRows.Count);
Assert.AreEqual($"{_textFieldName}", errors[0].AffectedComponent);
Assert.AreEqual("RegularExpression.FieldValueDoesNotMatchRegularExpression",
errors[0].IssueCode?.ID);
}
finally
{
_testWs = initTestWs;
}
}
private ITable CreateTestTable([NotNull] string tableName, out int cvFieldIndex,
out int rangeFieldIndex)
{
IRangeDomain rangeDomain = DomainUtils.CreateRangeDomain(
tableName + "_range",
esriFieldType.esriFieldTypeInteger, 0, 100);
DomainUtils.AddDomain(_testWs, rangeDomain);
ICodedValueDomain cvDomain = DomainUtils.CreateCodedValueDomain(
tableName + "_cv",
esriFieldType.esriFieldTypeInteger, null,
esriSplitPolicyType.esriSPTDuplicate,
esriMergePolicyType.esriMPTDefaultValue,
new CodedValue(1, "Value 1"),
new CodedValue(2, "Value 2"),
new CodedValue(3, "Value 3"));
DomainUtils.AddDomain(_testWs, cvDomain);
IField cvField = FieldUtils.CreateIntegerField("CvField");
((IFieldEdit)cvField).Domain_2 = (IDomain)cvDomain;
IField rangeField = FieldUtils.CreateIntegerField("RangeField");
((IFieldEdit)rangeField).Domain_2 = (IDomain)rangeDomain;
ITable table = DatasetUtils.CreateTable(_testWs,
tableName,
FieldUtils.CreateOIDField(),
cvField,
rangeField);
cvFieldIndex = table.FindField(cvField.Name);
rangeFieldIndex = table.FindField(rangeField.Name);
return(table);
}
public void CanCreateIntegerCodedValueDomainConstraint()
{
ICodedValueDomain integerCvDomain = DomainUtils.CreateCodedValueDomain(
"CanCreateIntegerCodedValueDomainConstraint",
esriFieldType.esriFieldTypeInteger, null,
esriSplitPolicyType.esriSPTDuplicate,
esriMergePolicyType.esriMPTDefaultValue,
new CodedValue(1, "Value 1"),
new CodedValue(2, "Value 2"),
new CodedValue(3, "Value 3"));
DomainUtils.AddDomain(_testWs, integerCvDomain);
IField integerField = FieldUtils.CreateIntegerField("IntegerField");
((IFieldEdit)integerField).Domain_2 = (IDomain)integerCvDomain;
ITable table = DatasetUtils.CreateTable(_testWs,
"CanCreateIntegerCodedValueDomainConstraint",
FieldUtils.CreateOIDField(),
integerField);
List <ConstraintNode> constraints =
GdbConstraintUtils.GetGdbConstraints(table);
Assert.NotNull(constraints);
foreach (ConstraintNode constraint in constraints)
{
Console.WriteLine(constraint);
}
Assert.AreEqual(2, constraints.Count);
Assert.AreEqual("IntegerField IS NULL OR (IntegerField IN (1, 2, 3))",
constraints[0].Condition);
Assert.AreEqual("OBJECTID >= 0", constraints[1].Condition);
}
private static IFeatureClass CreateLineClass([NotNull] IFeatureWorkspace ws)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateIntegerField(_nrFieldName));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, false, false));
Thread.Sleep(10);
IFeatureClass featureClass =
DatasetUtils.CreateSimpleFeatureClass(
ws, "line_" + Environment.TickCount, fields, null);
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
return(featureClass);
}
public void TestRelatedFactory()
{
IFeatureWorkspace initTestWs = _testWs;
try
{
_testWs = RelTestWs;
IFeatureClass fc1 = CreateFeatureClass("TestRelatedFactory",
esriGeometryType.esriGeometryPolyline);
var ds1 = (IDataset)fc1;
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateIntegerField(_fkFieldName));
fields.AddField(FieldUtils.CreateTextField(_textFieldName, 200));
string tableName = ds1.Name + "_table";
ITable table = TestWorkspaceUtils.CreateSimpleTable(_testWs, tableName, fields);
var tableDataset = (IDataset)table;
string relClassName = "relClass" + Math.Abs(Environment.TickCount);
IRelationshipClass rel = TestWorkspaceUtils.CreateSimpleMNRelationship(
_testWs, relClassName, table, (ITable)fc1, "fkGrp", "fkFc");
((IWorkspaceEdit)_testWs).StartEditing(false);
IFeature f = AddFeature(fc1,
CurveConstruction.StartLine(0, 0)
.LineTo(4, 0)
.Curve);
IRow r = AddRow(table, textFieldValue: "A");
rel.CreateRelationship((IObject)r, f);
r = AddRow(table, textFieldValue: "B");
rel.CreateRelationship((IObject)r, f);
f = AddFeature(fc1,
CurveConstruction.StartLine(4, 0)
.LineTo(4, 8)
.Curve);
r = AddRow(table, textFieldValue: "A");
rel.CreateRelationship((IObject)r, f);
((IWorkspaceEdit)_testWs).StopEditing(true);
var model = new SimpleModel("model", fc1);
Dataset mds1 = model.AddDataset(new ModelVectorDataset(ds1.Name));
Dataset mdsRel = model.AddDataset(new ModelTableDataset(tableDataset.Name));
var clsDesc = new ClassDescriptor(typeof(QaRelRegularExpression));
var tstDesc = new TestDescriptor("GroupEnds", clsDesc);
var condition = new QualityCondition("cndGroupEnds", tstDesc);
QualityConditionParameterUtils.AddParameterValue(condition, "relationTables", mds1);
QualityConditionParameterUtils.AddParameterValue(condition, "relationTables", mdsRel);
QualityConditionParameterUtils.AddParameterValue(condition, "relation", relClassName);
QualityConditionParameterUtils.AddParameterValue(condition, "join", JoinType.InnerJoin);
QualityConditionParameterUtils.AddParameterValue(condition, "pattern", "A");
QualityConditionParameterUtils.AddParameterValue(condition, "fieldNames",
$"{tableName}.{_textFieldName}");
QualityConditionParameterUtils.AddParameterValue(condition, "MatchIsError", false);
//condition.AddParameterValue("PatternDescription", "Hallo");
var factory = new QaRelRegularExpression {
Condition = condition
};
IList <ITest> tests =
factory.CreateTests(new SimpleDatasetOpener(model.MasterDatabaseWorkspaceContext));
Assert.AreEqual(1, tests.Count);
IList <QaError> errors = Run(tests[0], 1000);
AssertErrors(1, errors);
IList <InvolvedRow> involvedRows = errors[0].InvolvedRows;
Assert.AreEqual(2, involvedRows.Count);
Assert.AreEqual($"{tableName}.{_textFieldName}", errors[0].AffectedComponent);
Assert.AreEqual("RegularExpression.FieldValueDoesNotMatchRegularExpression",
errors[0].IssueCode?.ID);
// TOP-4945: expected involved dataset name: base table name, not joined table name
Assert.IsTrue(tableName == involvedRows[0].TableName ||
tableName == involvedRows[1].TableName);
}
finally
{
_testWs = initTestWs;
}
}
private void TestWithTolerance(IFeatureWorkspace ws)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateIntegerField("LineTyp", "LineTyp"));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000, false, false));
IFeatureClass fc =
DatasetUtils.CreateSimpleFeatureClass(ws, "TestWithTolerance", fields,
null);
IList <ITable> tbls = new[] { (ITable)fc };
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
{
IFeature row = fc.CreateFeature();
row.set_Value(1, 1);
row.Shape =
CurveConstruction.StartLine(100, 99.93).LineTo(200, 200).Curve;
row.Store();
}
{
IFeature row = fc.CreateFeature();
row.set_Value(1, 2);
row.Shape =
CurveConstruction.StartLine(100, 99.95).LineTo(100, 200).Curve;
row.Store();
}
IList <QaConnectionRule> rules = new[]
{
new QaConnectionRule(tbls, new[] { "LineTyp = 1" }),
new QaConnectionRule(tbls, new[] { "LineTyp = 2" })
};
var test = new QaConnections(new[] { fc }, rules, 0.2);
test.QaError += Test_QaError;
_errorCount = 0;
test.Execute();
Assert.AreEqual(1, _errorCount);
test.QaError -= Test_QaError;
var container = new TestContainer();
container.AddTest(test);
container.TileSize = 100;
IEnvelope box = new EnvelopeClass();
container.QaError += Test_QaError;
_errorCount = 0;
container.Execute();
Assert.AreEqual(1, _errorCount);
_errorCount = 0;
box.PutCoords(0, 0, 300, 300);
container.Execute(box);
Assert.AreEqual(1, _errorCount);
_errorCount = 0;
box.PutCoords(1, 0, 300, 300);
container.Execute(box);
Assert.AreEqual(1, _errorCount);
}
public void CanCheckTupleKeysContainingNull()
{
const string key1 = "KEY1";
const string key2 = "KEY2";
const string fkey1 = "FKEY1";
const string fkey2 = "FKEY2";
ITable referencedTable = DatasetUtils.CreateTable(
_workspace,
string.Format("{0}_keys", MethodBase.GetCurrentMethod().Name),
FieldUtils.CreateOIDField(),
FieldUtils.CreateIntegerField(key1),
FieldUtils.CreateTextField(key2, 10));
ITable referencingTable = DatasetUtils.CreateTable(
_workspace,
string.Format("{0}_fkeys", MethodBase.GetCurrentMethod().Name),
FieldUtils.CreateOIDField(),
FieldUtils.CreateTextField(fkey1, 10),
FieldUtils.CreateTextField(fkey2, 10));
GdbObjectUtils.CreateRow(referencedTable,
new Dictionary <string, object>
{
{ key1, 1000 },
{ key2, "AAA" }
}).Store();
GdbObjectUtils.CreateRow(referencedTable,
new Dictionary <string, object>
{
{ key1, 2000 },
{ key2, null }
}).Store();
GdbObjectUtils.CreateRow(referencingTable,
new Dictionary <string, object>
{
{ fkey1, "1000" },
{ fkey2, "AAA" }
}).Store();
// valid reference with null key
GdbObjectUtils.CreateRow(referencingTable,
new Dictionary <string, object>
{
{ fkey1, "2000" },
{ fkey2, null }
}).Store();
// dangling reference:
GdbObjectUtils.CreateRow(referencingTable,
new Dictionary <string, object>
{
{ fkey1, "3000" },
{ fkey2, null }
}).Store();
var runner = new QaTestRunner(
new QaForeignKey(referencingTable, new[] { fkey1, fkey2 },
referencedTable, new[] { key1, key2 }));
runner.Execute();
Assert.AreEqual(1, runner.Errors.Count);
}
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);
}
public void TestRelatedFactoryMinParameters()
{
IFeatureWorkspace testWs = RelTestWs;
const string fkTable = "fkTable";
IFeatureClass fc1 = CreateLineClass(
testWs, "Fc1_" + Environment.TickCount,
new List <IField> {
FieldUtils.CreateIntegerField(fkTable)
});
IFeatureClass fc2 = CreateLineClass(testWs, "Fc2_" + Environment.TickCount);
var ds1 = (IDataset)fc1;
var ds2 = (IDataset)fc2;
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
const string IdField = "IdRel";
fields.AddField(FieldUtils.CreateIntegerField(IdField));
string relTableName = "Rel_" + ds1.Name;
ITable relTable = TestWorkspaceUtils.CreateSimpleTable(testWs, relTableName,
fields);
var dsRel = (IDataset)relTable;
string relName = "relName" + Environment.TickCount;
IRelationshipClass rel = TestWorkspaceUtils.CreateSimple1NRelationship(
testWs, relName, relTable, (ITable)fc1, relTable.OIDFieldName, fkTable);
((IWorkspaceEdit)testWs).StartEditing(false);
IRow r1 = AddRow(relTable, new object[] { 12 });
IRow r2 = AddRow(relTable, new object[] { 14 });
IFeature f11 = AddFeature(
fc1, CurveConstruction.StartLine(0, 0).LineTo(4, 0).Curve, new object[] { r1.OID });
IFeature f12 = AddFeature(
fc1, CurveConstruction.StartLine(0, 0).LineTo(4, 0).Curve, new object[] { r2.OID });
IFeature f2 = AddFeature(fc2, CurveConstruction.StartLine(10, 1).LineTo(14, 1).Curve);
((IWorkspaceEdit)testWs).StopEditing(true);
var model = new SimpleModel("model", fc1);
Dataset mds1 = model.AddDataset(new ModelVectorDataset(ds1.Name));
Dataset mdsRel = model.AddDataset(new ModelTableDataset(dsRel.Name));
Dataset mds2 = model.AddDataset(new ModelVectorDataset(ds2.Name));
var clsDesc = new ClassDescriptor(typeof(QaRelMustBeNearOther));
var tstDesc = new TestDescriptor("testNear", clsDesc);
var condition = new QualityCondition("cndNear", tstDesc);
QualityConditionParameterUtils.AddParameterValue(condition, "relationTables", mds1);
QualityConditionParameterUtils.AddParameterValue(condition, "relationTables", mdsRel,
$"{relTableName}.{IdField} = 12"); // --> only f11 get's checked
QualityConditionParameterUtils.AddParameterValue(condition, "relation", relName);
QualityConditionParameterUtils.AddParameterValue(condition, "join", JoinType.InnerJoin);
QualityConditionParameterUtils.AddParameterValue(condition, "nearClasses", mds2);
QualityConditionParameterUtils.AddParameterValue(condition, "maximumDistance", 5);
QualityConditionParameterUtils.AddParameterValue(condition, "relevantRelationCondition",
string.Empty);
var fact = new QaRelMustBeNearOther();
fact.Condition = condition;
IList <ITest> tests =
fact.CreateTests(new SimpleDatasetOpener(model.MasterDatabaseWorkspaceContext));
Assert.AreEqual(1, tests.Count);
var runner = new QaContainerTestRunner(1000, tests[0]);
runner.Execute();
Assert.AreEqual(1, 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);
}
}
