public void CanTestPseudoNodesFactory()
{
IFeatureWorkspace ws =
TestWorkspaceUtils.CreateInMemoryWorkspace("CanTestPseudoNodes");
IFeatureClass fc = CreateLineClass(ws);
IFeature row1 = fc.CreateFeature();
row1.Shape =
CurveConstruction.StartLine(0, 0).LineTo(1, 1).LineTo(1, 0).LineTo(0, 0).Curve;
row1.set_Value(fc.Fields.FindField(_nrFieldName), 1);
row1.Store();
var ds1 = (IDataset)fc;
var model = new SimpleModel("model", fc);
Dataset mds1 = model.AddDataset(new ModelVectorDataset(ds1.Name));
var clsDesc = new ClassDescriptor(typeof(QaFactoryPseudoNodes));
var tstDesc = new TestDescriptor("GroupEnds", clsDesc);
var condition = new QualityCondition("cndPseudoNodes", tstDesc);
QualityConditionParameterUtils.AddParameterValue(
condition, QaFactoryPseudoNodes.PolylineClassesParam, mds1);
QualityConditionParameterUtils.AddParameterValue(
condition, QaFactoryPseudoNodes.IgnoreFieldsParam, _nrFieldName);
QualityConditionParameterUtils.AddParameterValue(
condition, QaFactoryPseudoNodes.IgnoreFieldsParam,
QaFactoryPseudoNodes.EndLayerFields);
// implicit: ignoreLoopEndPoints = false
var fact = new QaFactoryPseudoNodes();
fact.Condition = condition;
IList <ITest> tests =
fact.CreateTests(new SimpleDatasetOpener(model.MasterDatabaseWorkspaceContext));
Assert.AreEqual(1, tests.Count);
ITest test = tests[0];
var runner = new QaTestRunner(test);
runner.Execute();
Assert.AreEqual(1, runner.Errors.Count);
// set ignoreLoopEndPoints = true and rerun
QualityConditionParameterUtils.AddParameterValue(
condition, QaFactoryPseudoNodes.IgnoreLoopEndPointsParam, true);
fact.Condition = condition;
tests = fact.CreateTests(new SimpleDatasetOpener(model.MasterDatabaseWorkspaceContext));
Assert.AreEqual(1, tests.Count);
test = tests[0];
runner = new QaTestRunner(test);
runner.Execute();
Assert.AreEqual(0, runner.Errors.Count);
}
public void CanIgnoreNullValues()
{
int cvFieldIndex;
int rangeFieldIndex;
ITable table = CreateTestTable("table3",
out cvFieldIndex,
out rangeFieldIndex);
var row1 = table.CreateRow();
row1.Store();
var row2 = table.CreateRow();
row2.Value[cvFieldIndex] = 2; // valid in domain
row2.Value[rangeFieldIndex] = 50; // valid in domain
row2.Store();
var row3 = table.CreateRow();
row3.Value[cvFieldIndex] = 4; // not valid for domain
row3.Value[rangeFieldIndex] = 200; // valid in domain
row3.Store();
var model = new SimpleModel("model", table);
var tableDataset = model.AddDataset(
new ModelTableDataset(DatasetUtils.GetName(table)));
var condition = new QualityCondition(
"condition",
new TestDescriptor("testdescriptor",
new ClassDescriptor(typeof(QaGdbConstraintFactory))));
QualityConditionParameterUtils.AddParameterValue(condition, "table", tableDataset);
var factory = new QaGdbConstraintFactory {
Condition = condition
};
IList <ITest> tests =
factory.CreateTests(new SimpleDatasetOpener(model.MasterDatabaseWorkspaceContext));
Assert.AreEqual(1, tests.Count);
var runner = new QaTestRunner(tests[0]);
runner.Execute();
Assert.AreEqual(2, runner.Errors.Count);
Assert.AreEqual(
"Domain table3_cv - Invalid value combination: CVFIELD = 4",
runner.Errors[0].Description);
Assert.AreEqual(
"Domain table3_range - Invalid value combination: RANGEFIELD = 200",
runner.Errors[1].Description);
}
public QualityCondition ToQualityCondition()
{
var clsDesc = new ClassDescriptor(typeof(QaDatasetConstraintFactory));
var testDesc = new TestDescriptor("QaDatasetConstraintFactory", clsDesc);
var qc = new QualityCondition("qc_dataset_" + Dataset.Name, testDesc);
QualityConditionParameterUtils.AddParameterValue(
qc, QaDatasetConstraintFactory.TableAttribute, Dataset);
AddParameters(qc, Constraints, "");
return(qc);
}
private static void AddParameters(QualityCondition qualityCondition,
IEnumerable <ConstraintNode> nodes, string prefix)
{
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
Assert.ArgumentNotNull(nodes, nameof(nodes));
string subPrefix = prefix + "+";
foreach (ConstraintNode node in nodes)
{
QualityConditionParameterUtils.AddParameterValue(
qualityCondition, QaDatasetConstraintFactory.ConstraintAttribute,
prefix + node.Condition);
AddParameters(qualityCondition, node.Nodes, subPrefix);
}
}
public void CanTestFactory()
{
Type type = typeof(QaMinSegAngleFactory);
var testDescriptor = new TestDescriptor
{
TestFactoryDescriptor = new ClassDescriptor(type)
};
const string fcName = "CanTestFactory";
IFeatureClass fc = CreateLineClass(_testWs, fcName);
IFeature row1 = fc.CreateFeature();
row1.Shape =
CurveConstruction.StartLine(0, 0, 0)
.LineTo(0, 1, 0)
.LineTo(0.1, 0, 0)
.LineTo(0.1, 1, 100)
.LineTo(0.1, 2, 100)
.CircleTo(GeometryFactory.CreatePoint(0.2, 0, 100))
.Curve;
row1.Store();
double limit = FormatUtils.Radians2AngleInUnits(0.1, AngleUnit.Degree);
var model = new SimpleModel("model", fc);
esriGeometryType esriGeometryType = fc.ShapeType;
var suiteGeometryType = (ProSuiteGeometryType)esriGeometryType;
ModelVectorDataset ds = model.AddDataset(
new ModelVectorDataset(fcName)
{
GeometryType = new GeometryTypeShape(suiteGeometryType.ToString(),
suiteGeometryType)
});
var condition = new QualityCondition("testtest", testDescriptor);
QualityConditionParameterUtils.AddParameterValue(condition, "featureClass", ds);
QualityConditionParameterUtils.AddParameterValue(condition, "limit", limit);
QualityConditionParameterUtils.AddParameterValue(condition, "is3D", true);
TestFactory factory = TestFactoryUtils.CreateTestFactory(condition);
Assert.IsNotNull(factory);
IList <ITest> tests =
factory.CreateTests(new SimpleDatasetOpener(model.MasterDatabaseWorkspaceContext));
Assert.AreEqual(1, tests.Count);
ITest test = tests[0];
var runner = new QaContainerTestRunner(1000, test);
runner.Execute();
Assert.AreEqual(2, 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);
}
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;
}
}
public void CanTranslateSql()
{
IFeatureClass fc;
ITable table;
IRelationshipClass rc;
CreateTestWorkspace(
"CanTranslateSql_master", "fc", "table", "rc",
out fc, out table, out rc);
IFeatureClass fc_child;
ITable table_child;
IRelationshipClass rc_child;
IFeatureWorkspace childWorkspace = CreateTestWorkspace(
"CanTranslateSql_child", "fc_child", "table_child", "rc_child",
out fc_child, out table_child, out rc_child);
IRow t = table_child.CreateRow();
t.Value[table_child.FindField("TEXT")] = "table"; // same as table name
int pk = t.OID;
t.Store();
IFeature f = fc_child.CreateFeature();
f.Value[fc_child.FindField("FKEY")] = pk;
f.Shape = GeometryFactory.CreatePoint(100, 200);
f.Store();
var model = new SimpleModel("model", fc);
ModelVectorDataset vectorDataset = model.AddDataset(
new ModelVectorDataset(DatasetUtils.GetName(fc)));
ModelTableDataset tableDataset = model.AddDataset(
new ModelTableDataset(DatasetUtils.GetName(table)));
AttributeHarvestingUtils.HarvestAttributes(
vectorDataset, ModelElementUtils.GetMasterDatabaseWorkspaceContext(vectorDataset));
AttributeHarvestingUtils.HarvestAttributes(
tableDataset, ModelElementUtils.GetMasterDatabaseWorkspaceContext(tableDataset));
ObjectAttribute fkAttribute = vectorDataset.GetAttribute("FKEY");
ObjectAttribute pkAttribute = tableDataset.GetAttribute(table.OIDFieldName);
Assert.NotNull(fkAttribute);
Assert.NotNull(pkAttribute);
Association association =
model.AddAssociation(new ForeignKeyAssociation(DatasetUtils.GetName(rc),
AssociationCardinality.OneToMany,
fkAttribute, pkAttribute));
var childWorkspaceContext = new SimpleWorkspaceContext(
model, childWorkspace,
new[]
{
new WorkspaceDataset("fc_child", null, vectorDataset),
new WorkspaceDataset("table_child", null, tableDataset),
},
new[]
{
new WorkspaceAssociation("rc_child", null, association)
});
var clsDesc = new ClassDescriptor(typeof(QaRelConstraint));
var tstDesc = new TestDescriptor("RelConstraint", clsDesc);
QualityCondition condition = new QualityCondition("fc_table_constraints", tstDesc);
QualityConditionParameterUtils.AddParameterValue(condition, "relationTables", vectorDataset);
QualityConditionParameterUtils.AddParameterValue(condition, "relationTables", tableDataset);
QualityConditionParameterUtils.AddParameterValue(condition, "relation", "rc");
QualityConditionParameterUtils.AddParameterValue(condition, "join", JoinType.InnerJoin);
QualityConditionParameterUtils.AddParameterValue(condition, "constraint",
"(fc.OBJECTID = 1 AND table.OBJECTID = 1) AND (table.TEXT = 'table')");
var factory = new QaRelConstraint {
Condition = condition
};
ITest test = factory.CreateTests(new SimpleDatasetOpener(childWorkspaceContext))[0];
var runner = new QaContainerTestRunner(1000, test);
runner.Execute(GeometryFactory.CreateEnvelope(0, 0, 1000, 1000));
AssertUtils.NoError(runner);
}
