public void CanAllowIntersectingFootPrintsWithDifferentPointIds()
{
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, id1)
.Add(10, 10, 0, id1)
.Add(0, 10, 0, id1)
.StartOuterRing(9, 0, 10, id2)
.Add(20, 0, 10, id2)
.Add(20, 10, 10, id2)
.Add(9, 10, 10, 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);
AssertUtils.NoError(runner);
}
public void CanAllowMultipartFootPrintTouchingInLine()
{
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, 5, 100)
.Add(20, 5, 100)
.Add(20, 15, 100)
.Add(10, 15, 100);
IFeature row1 = featureClassMock.CreateFeature(construction.MultiPatch);
const bool allowIntersectionsForDifferentPointIds = true;
var test = new QaMpNonIntersectingRingFootprints(featureClassMock,
allowIntersectionsForDifferentPointIds);
var runner = new QaTestRunner(test);
runner.Execute(row1);
AssertUtils.NoError(runner);
}
public void TestUniqueIntegers()
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField("Unique",
esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(_pgdbWorkspace, "Unique1",
fields);
for (var i = 0; i < 10; i++)
{
IRow row = table.CreateRow();
row.set_Value(1, i);
row.Store();
}
foreach (bool forceInMemoryTableSort in new[] { false, true })
{
var test = new QaUnique(table, "Unique")
{
ForceInMemoryTableSorting = forceInMemoryTableSort
};
var runner = new QaTestRunner(test);
runner.Execute();
AssertUtils.NoError(runner);
}
}
public void CanAllowSingleConnectedLineShorterThanNearDistance()
{
const string testName = "CanAllowSingleConnectedLineShorterThanNearDistance";
IFeatureClass lineClass = CreateFeatureClass(string.Format("{0}_lines", testName),
esriGeometryType.esriGeometryPolyline);
IFeature longLine = lineClass.CreateFeature();
longLine.Shape = CurveConstruction.StartLine(0, 0)
.LineTo(100, 0)
.Curve;
longLine.Store();
IFeature shortLine = lineClass.CreateFeature();
shortLine.Shape = CurveConstruction.StartLine(100, 0)
.LineTo(101, 0)
.Curve;
shortLine.Store();
IEnvelope verificationEnvelope = GeometryFactory.CreateEnvelope(0, 0, 500, 500);
var test = new QaNodeLineCoincidence(lineClass, new[] { lineClass }, 2, false);
var runner = new QaContainerTestRunner(1000, test);
runner.Execute(verificationEnvelope);
AssertUtils.NoError(runner);
}
public void CanAllowIntersectingFootPrintsWithVerticalWall()
{
FeatureClassMock featureClassMock = CreateFeatureClassMock();
var construction = new MultiPatchConstruction();
// second ring is vertical wall, intersecting the first ring
construction.StartOuterRing(0, 0, 0)
.Add(10, 0, 0)
.Add(10, 10, 0)
.Add(0, 10, 0)
.StartOuterRing(5, 5, 100)
.Add(15, 5, 100)
.Add(15, 5, 110)
.Add(5, 5, 110);
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.NoError(runner);
}
private static void CanDetect1ToNUnique([NotNull] IFeatureWorkspace workspace)
{
const string uniqueFieldName = "Unique";
ITable tableOrig;
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField(
uniqueFieldName, esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(
workspace, "Relate1NUnique1", fields);
for (var i = 0; i < 10; i++)
{
IRow row = table.CreateRow();
row.set_Value(1, i);
row.Store();
}
tableOrig = table;
}
ITable tableRel;
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField(
"Ref", esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(
workspace, "Relate1NUnique2", fields);
for (var i = 0; i < 10; i++)
{
IRow row = table.CreateRow();
row.set_Value(1, i);
row.Store();
}
tableRel = table;
}
IRelationshipClass rel =
TestWorkspaceUtils.CreateSimple1NRelationship(workspace,
"rel1NUnique", tableOrig,
tableRel, uniqueFieldName, "Ref");
ITable relTab = TableJoinUtils.CreateQueryTable(rel, JoinType.InnerJoin);
foreach (bool forceInMemoryTableSort in new[] { true, false })
{
var test = new QaUnique(relTab, "Relate1NUnique1." + uniqueFieldName)
{
ForceInMemoryTableSorting = forceInMemoryTableSort
};
var runner = new QaTestRunner(test);
runner.Execute();
AssertUtils.NoError(runner);
}
}
public void CanTestDefinedExtentMultipleTilesWithLinesNearTileBoundary()
{
IPolycurve leftOfTileBoundary = CurveConstruction.StartLine(99.5, 10)
.LineTo(99.5, 90)
.Curve;
IPolycurve rightOfTileBoundary = CurveConstruction.StartLine(100.5, 10)
.LineTo(100.5, 90)
.Curve;
IFeatureClass fc = CreateLineClass(_testWs, "CanTestDefinedExtentMultipleTiles_fc");
IFeature row = fc.CreateFeature();
row.Shape = rightOfTileBoundary;
row.Store();
IFeatureClass nearClass = CreateLineClass(_testWs,
"CanTestDefinedExtentMultipleTiles_near");
IFeature nearRow = nearClass.CreateFeature();
nearRow.Shape = leftOfTileBoundary;
nearRow.Store();
IPolygon polygon = GeometryFactory.CreatePolygon(
GeometryFactory.CreateEnvelope(0, 0, 200, 200));
const double maximumDistance = 1.5;
// one tile for the entire verification extent
QaContainerTestRunner runnerLargeTileSize = CreateTestRunner(
fc, nearClass, 200, maximumDistance);
runnerLargeTileSize.Execute(polygon);
AssertUtils.NoError(runnerLargeTileSize);
// 4 tiles.
// The feature is in the second tile, to the right of the left tile boundary, but within the search distance of it.
// The 'near feature' is in the first tile, to the left of the right tile boundary, but within the search distance of it.
// NOTE currently this results in an error, since the 'near feature' is not returned again for the second tile
// (the test container assumes that it was already considered in the first tile; in this case however, it is
// needed for a feature in the *second* tile, which was not yet returned for the first tile.
// -> if the search geometry overlaps the tile boundary but the source feature for the search DOES NOT, then
// features must be returned by the search even if they overlap a previous tile
QaContainerTestRunner runnerSmallTileSize = CreateTestRunner(
fc, nearClass, 100, maximumDistance);
runnerSmallTileSize.Execute(polygon);
AssertUtils.NoError(runnerSmallTileSize);
}
public void CanTestNonEmptyGeometry_Point()
{
IFeatureClass fc = new FeatureClassMock(1, "PointFc",
esriGeometryType.esriGeometryPoint);
IFeature feature = fc.CreateFeature();
feature.Shape = GeometryFactory.CreatePoint(0, 0);
feature.Store();
var test = new QaNonEmptyGeometry(fc);
var runner = new QaTestRunner(test);
runner.Execute(feature);
AssertUtils.NoError(runner);
}
public void CanTestNonEmptyGeometry_Polyline()
{
IFeatureClass fc = new FeatureClassMock(1, "LineFc",
esriGeometryType.esriGeometryPolyline);
IFeature feature = fc.CreateFeature();
feature.Shape = CurveConstruction.StartLine(0, 0).LineTo(10, 10).Curve;
feature.Store();
var test = new QaNonEmptyGeometry(fc);
var runner = new QaTestRunner(test);
runner.Execute(feature);
AssertUtils.NoError(runner);
}
public void CanAllowUndefinedMinimumOffset()
{
var verified = new FeatureClassMock(1, "v", _gt)
{
RowCountResult = 500
};
var r = new FeatureClassMock(2, "r", _gt)
{
RowCountResult = 1000
};
var test = new QaRowCount(verified, new ITable[] { r }, "", "0");
var runner = new QaTestRunner(test);
runner.Execute();
AssertUtils.NoError(runner);
}
public void CanAllowRowCountAtMaximumValueWithReferenceTable()
{
var verified = new FeatureClassMock(1, "v", _gt)
{
RowCountResult = 1100
};
var r = new FeatureClassMock(2, "r1", _gt)
{
RowCountResult = 1000
};
var test = new QaRowCount(verified, new ITable[] { r }, "-10%", "+10%");
var runner = new QaTestRunner(test);
runner.Execute();
AssertUtils.NoError(runner);
}
public void CanAllowSimpleMultiPatch()
{
FeatureClassMock featureClassMock = CreateFeatureClassMock();
var construction = new MultiPatchConstruction();
construction.StartOuterRing(0, 0, 0)
.Add(10, 0, 0)
.Add(10, 10, 0)
.Add(0, 10, 0);
IFeature row = featureClassMock.CreateFeature(construction.MultiPatch);
var test = new QaMpSinglePartFootprint(featureClassMock);
var runner = new QaTestRunner(test);
runner.Execute(row);
AssertUtils.NoError(runner);
}
public void TestUniqueStrings()
{
ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true);
SpatialReferenceUtils.SetXYDomain(sref, -10000, -10000, 10000, 10000, 0.0001, 0.001);
IFields fields = FieldUtils.CreateFields(
FieldUtils.CreateOIDField(),
FieldUtils.CreateTextField("Unique", 100),
FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPoint,
sref, 1000));
IFeatureClass featureClass = DatasetUtils.CreateSimpleFeatureClass(_pgdbWorkspace,
"TestUniqueStrings",
fields);
for (var i = 0; i < 10; i++)
{
IFeature feature = featureClass.CreateFeature();
feature.set_Value(1, string.Format("A'{0}{1}", i, "\""));
feature.Shape = GeometryFactory.CreatePoint(100, 100, sref);
feature.Store();
}
IEnvelope testEnvelope = GeometryFactory.CreateEnvelope(0, 0, 200, 200, sref);
foreach (bool forceInMemoryTableSort in new[] { false, true })
{
var test = new QaUnique((ITable)featureClass, "Unique")
{
ForceInMemoryTableSorting = forceInMemoryTableSort
};
var runner = new QaTestRunner(test);
runner.Execute(testEnvelope);
AssertUtils.NoError(runner);
}
}
public void CanAllowVertexWithinCoincidenceTolerance()
{
const string testName = "CanAllowVertexWithinCoincidenceTolerance";
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(1, 0.1);
nodeRow.Store();
IFeature nearRow = nearClass.CreateFeature();
nearRow.Shape = CurveConstruction.StartLine(0, 0)
.LineTo(2, 0)
.Curve;
nearRow.Store();
IEnvelope verificationEnvelope = GeometryFactory.CreateEnvelope(0, 0, 500, 500);
var test = new QaNodeLineCoincidence(nodeClass, nearClasses, 2)
{
CoincidenceTolerance = 0.2
};
var runner = new QaContainerTestRunner(1000, test);
runner.Execute(verificationEnvelope);
AssertUtils.NoError(runner);
}
private static void CanDetectNtoMUnique([NotNull] IFeatureWorkspace workspace)
{
const string uniqueFieldName = "FIELD_UNIQUE";
const string foreignKeyFieldName = "FOREIGN_KEY_FIELD";
ITable tableOrig;
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField(uniqueFieldName,
esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(workspace, "RelateUnique1",
fields,
null);
tableOrig = table;
}
ITable tableRel;
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField(foreignKeyFieldName,
esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(workspace, "RelateUnique2",
fields,
null);
tableRel = table;
}
IRelationshipClass rel = TestWorkspaceUtils.CreateSimpleMNRelationship(
workspace, "NToMRelTable", tableOrig, tableRel, uniqueFieldName,
foreignKeyFieldName);
{
((IWorkspaceEdit)workspace).StartEditing(false);
for (var i = 0; i < 10; i++)
{
IRow row = tableOrig.CreateRow();
row.set_Value(1, i);
row.Store();
}
for (var i = 0; i < 10; i++)
{
IRow row = tableRel.CreateRow();
row.set_Value(1, i);
row.Store();
rel.CreateRelationship((IObject)tableOrig.GetRow(i + 1),
(IObject)row);
}
((IWorkspaceEdit)workspace).StopEditing(true);
}
ITable relTab = TableJoinUtils.CreateQueryTable(rel, JoinType.InnerJoin);
foreach (bool forceInMemoryTableSort in new[] { true, false })
{
var test = new QaUnique(relTab, "RelateUnique1." + uniqueFieldName)
{
ForceInMemoryTableSorting = forceInMemoryTableSort
};
var runner = new QaTestRunner(test);
runner.Execute();
AssertUtils.NoError(runner);
}
}
public void TestNonUniqueIntegers()
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField("Unique",
esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(_pgdbWorkspace, "NonUnique",
fields);
for (var i = 0; i < 10; i++)
{
IRow row = table.CreateRow();
row.set_Value(1, i);
row.Store();
}
// create error values
{
IRow row = table.CreateRow();
row.set_Value(1, 5);
row.Store();
}
IRow errorRow = table.CreateRow();
errorRow.set_Value(1, 5);
errorRow.Store();
{
IRow row = table.CreateRow();
row.set_Value(1, 7);
row.Store();
}
IRow validRow = table.CreateRow();
validRow.set_Value(1, 12);
validRow.Store();
foreach (bool forceInMemoryTableSort in new[] { true, false })
{
// init Test
var test = new QaUnique(table, "Unique")
{
ForceInMemoryTableSorting = forceInMemoryTableSort
};
// Run global test
var runner = new QaTestRunner(test);
runner.Execute();
Assert.AreEqual(5, runner.Errors.Count); // each non unique row is reported
// Run valid row
runner = new QaTestRunner(test);
runner.Execute(new[] { validRow });
AssertUtils.NoError(runner);
// Run error row
runner = new QaTestRunner(test);
runner.Execute(new[] { errorRow });
Assert.AreEqual(3, runner.Errors.Count); // '5' exists in 3 rows
// Run combined
runner = new QaTestRunner(test);
runner.Execute(new[] { validRow, errorRow });
Assert.AreEqual(3, runner.Errors.Count);
}
}
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);
}
