public void MissingPrefix()
{
IDomain domain1 = DomainUtils.AddDomain(TestWorkspace, CreateCVDomain("PRE_FIELD1"));
IDomain domain2 = DomainUtils.AddDomain(TestWorkspace, CreateRangeDomain("FIELD2"));
IField field1 = FieldUtils.CreateField("FIELD1", esriFieldType.esriFieldTypeInteger);
IField field2 = FieldUtils.CreateField("FIELD2", esriFieldType.esriFieldTypeInteger);
IField field3 = FieldUtils.CreateTextField("FIELD3", 20);
((IFieldEdit)field1).Domain_2 = domain1;
((IFieldEdit)field2).Domain_2 = domain2;
ITable table = DatasetUtils.CreateTable(TestWorkspace,
MethodBase.GetCurrentMethod().Name,
FieldUtils.CreateOIDField(),
field1, field2, field3);
const int maxLength = 10;
const bool mustContainFieldName = true;
var runner = new QaTestRunner(
new QaSchemaFieldDomainNames(table, "PRE_", maxLength, mustContainFieldName,
ExpectedCase.AllUpper));
runner.Execute();
Assert.AreEqual(1, runner.Errors.Count);
}
public void DoesNotContainFieldName()
{
IDomain domain1 = DomainUtils.AddDomain(TestWorkspace, CreateCVDomain("PRE_Field1"));
IDomain domain2 = DomainUtils.AddDomain(TestWorkspace,
CreateRangeDomain("PRE_FIELD2"));
IField field1 = FieldUtils.CreateField("FIELD1", esriFieldType.esriFieldTypeInteger);
IField field2 = FieldUtils.CreateField("FIELD2", esriFieldType.esriFieldTypeInteger);
IField field3 = FieldUtils.CreateField("FIELD3", esriFieldType.esriFieldTypeInteger);
((IFieldEdit)field1).Domain_2 = domain1; // case mismatch
((IFieldEdit)field2).Domain_2 = domain2;
((IFieldEdit)field3).Domain_2 = domain2; // assign again - different field name
ITable table = DatasetUtils.CreateTable(TestWorkspace,
MethodBase.GetCurrentMethod().Name,
FieldUtils.CreateOIDField(),
field1, field2, field3);
const int maxLength = 20;
const bool mustContainFieldName = true;
var runner = new QaTestRunner(
new QaSchemaFieldDomainNames(table, "PRE_", maxLength, mustContainFieldName,
ExpectedCase.Any));
runner.Execute();
Assert.AreEqual(2, runner.Errors.Count);
}
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 CanCheckGuids()
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField("UUID",
esriFieldType.esriFieldTypeGUID));
ITable table = TestWorkspaceUtils.CreateSimpleTable(_fgdbWorkspace, "CanCheckGuids",
fields);
Guid latest = Guid.NewGuid();
IRow row;
for (var i = 0; i < 10; i++)
{
latest = Guid.NewGuid();
row = table.CreateRow();
row.set_Value(1, latest.ToString("B"));
row.Store();
}
row = table.CreateRow();
row.set_Value(1, latest.ToString("B"));
row.Store();
//IWorkspace ws = TestDataUtils.OpenTopgisTlm();
//ITable table = ((IFeatureWorkspace) ws).OpenTable("TOPGIS_TLM.TLM_STRASSE");
var test = new QaUnique(table, "UUID");
var runner = new QaTestRunner(test);
runner.Execute();
Assert.AreEqual(2, runner.Errors.Count);
}
private static void TestReferencedGuid(IFeatureWorkspace ws)
{
IFieldsEdit fields1 = new FieldsClass();
fields1.AddField(FieldUtils.CreateOIDField());
fields1.AddField(FieldUtils.CreateField("Pk", esriFieldType.esriFieldTypeGUID));
ITable tbl1 = DatasetUtils.CreateTable(ws, "TestReferencedGuid1", null, fields1);
IFieldsEdit fields2 = new FieldsClass();
fields2.AddField(FieldUtils.CreateOIDField());
fields2.AddField(FieldUtils.CreateTextField("Fk", 50));
ITable tbl2 = DatasetUtils.CreateTable(ws, "TestReferencedGuid2", null, fields2);
IFieldsEdit fields3 = new FieldsClass();
fields3.AddField(FieldUtils.CreateOIDField());
fields3.AddField(FieldUtils.CreateField("Fk", esriFieldType.esriFieldTypeGUID));
ITable tbl3 = DatasetUtils.CreateTable(ws, "TestReferencedGuid3", null, fields3);
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
for (int i = 0; i < 5; i++)
{
Guid guid = Guid.NewGuid();
CreateRow(tbl1, guid.ToString("B"));
if (i % 2 == 0)
{
CreateRow(tbl2, guid.ToString());
}
else
{
CreateRow(tbl3, guid.ToString("B"));
}
}
var test = new QaUnreferencedRows(tbl1,
new[] { tbl2, tbl3 },
new[] { "pk,fk", "pk,fk" });
using (var r = new QaTestRunner(test))
{
r.Execute();
Assert.AreEqual(0, r.Errors.Count);
}
var container = new QaContainerTestRunner(10000, test);
container.Execute();
Assert.AreEqual(0, container.Errors.Count);
}
public void Duplicates()
{
IDomain domain1 = DomainUtils.AddDomain(_workspace,
DomainUtils.CreateCodedValueDomain(
"DOM_FIELD1",
esriFieldType.esriFieldTypeInteger,
"Description of DOM_FIELD1",
new CodedValue(1, "Value 1"),
new CodedValue(2, "Value 2")));
IDomain domain2 = DomainUtils.AddDomain(_workspace,
DomainUtils.CreateCodedValueDomain(
"DOM_FIELD2",
esriFieldType.esriFieldTypeInteger,
"Description of DOM_FIELD2",
new CodedValue(1, "Value 1"),
new CodedValue(2, "Value 2")));
// domain (not used in table) with duplicate name
DomainUtils.AddDomain(_workspace,
DomainUtils.CreateCodedValueDomain("DOM_FIELD3",
esriFieldType
.esriFieldTypeInteger,
"Description of DOM_FIELD2",
new CodedValue(1,
"Value 1"),
new CodedValue(2,
"Value 2")));
DomainUtils.AddDomain(_workspace,
DomainUtils.CreateRangeDomain("DOM_FIELD4",
esriFieldType.esriFieldTypeInteger,
0, 100,
"Description of DOM_FIELD2"));
IField field1 = FieldUtils.CreateField("FIELD1", esriFieldType.esriFieldTypeInteger);
IField field2 = FieldUtils.CreateField("FIELD2", esriFieldType.esriFieldTypeInteger);
IField field3 = FieldUtils.CreateTextField("FIELD3", 20);
((IFieldEdit)field1).Domain_2 = domain1;
((IFieldEdit)field2).Domain_2 = domain2;
ITable table = DatasetUtils.CreateTable(_workspace,
MethodBase.GetCurrentMethod().Name,
FieldUtils.CreateOIDField(),
field1, field2, field3);
const int maxLength = 25;
const bool noDuplicates = true;
var runner =
new QaTestRunner(new QaSchemaFieldDomainDescriptions(table, maxLength,
noDuplicates,
null));
runner.Execute();
Assert.AreEqual(1, runner.Errors.Count);
}
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);
}
}
private static void TestValueInUniqueTable(IFeatureWorkspace ws)
{
ITable table1 =
DatasetUtils.CreateTable(ws, "TestValueInUniqueTable1",
FieldUtils.CreateOIDField(),
FieldUtils.CreateField("RouteId",
esriFieldType
.esriFieldTypeInteger));
ITable table2 =
DatasetUtils.CreateTable(ws, "TestValueInUniqueTable2",
FieldUtils.CreateOIDField(),
FieldUtils.CreateField("OtherId",
esriFieldType
.esriFieldTypeInteger));
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
IRow row1 = table1.CreateRow();
row1.set_Value(1, 3);
row1.Store();
for (int i = 0; i < 5; i++)
{
IRow r = table1.CreateRow();
r.set_Value(1, 8);
r.Store();
}
IRow row2 = table2.CreateRow();
row2.set_Value(1, 3);
row2.Store();
const bool limitToTestedRows = false;
var test = new QaGroupConstraints(new[] { table1, table2 },
new[] { "RouteID", "OtherId" },
new[] { "'Haltung'", "'B'" },
1, limitToTestedRows);
using (var runner = new QaTestRunner(test))
{
runner.Execute();
Assert.AreEqual(1, runner.Errors.Count);
}
var containerRunner = new QaContainerTestRunner(100, test);
containerRunner.Execute();
Assert.AreEqual(1, containerRunner.Errors.Count);
}
public void TestUniqueGuid()
{
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.CreateField("UniqueValue", esriFieldType.esriFieldTypeGUID),
FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPoint,
sref, 1000));
IFeatureClass featureClass1 = DatasetUtils.CreateSimpleFeatureClass(_fgdbWorkspace,
"TestUniqueGuid",
fields);
for (var i = 0; i < 10; i++)
{
IFeature feature = featureClass1.CreateFeature();
feature.set_Value(1, Guid.NewGuid().ToString("B"));
feature.Shape = GeometryFactory.CreatePoint(100, 100, sref);
feature.Store();
}
for (var i = 0; i < 2; i++)
{
IFeature emptyFeature = featureClass1.CreateFeature();
emptyFeature.set_Value(1, null);
emptyFeature.Shape = GeometryFactory.CreatePoint(100, 100, sref);
emptyFeature.Store();
}
foreach (bool forceInMemoryTableSort in new[] { true, false })
{
var test = new QaUnique((ITable)featureClass1, "UniqueValue")
{
ForceInMemoryTableSorting = forceInMemoryTableSort
};
var runner = new QaTestRunner(test);
runner.Execute();
Assert.AreEqual(2, runner.Errors.Count);
}
}
public void NameTooLong()
{
IDomain domain1 = DomainUtils.AddDomain(_workspace,
DomainUtils.CreateCodedValueDomain(
"DOM_FIELD1",
esriFieldType.esriFieldTypeInteger,
new CodedValue(1, "Value 1 abc"),
new CodedValue(2, "Value 2")));
IDomain domain2 = DomainUtils.AddDomain(_workspace,
DomainUtils.CreateCodedValueDomain(
"DOM_FIELD2",
esriFieldType.esriFieldTypeInteger,
new CodedValue(1, "Value 1"),
new CodedValue(2, "Value 2 123")));
IField field1 = FieldUtils.CreateField("FIELD1", esriFieldType.esriFieldTypeInteger);
IField field2 = FieldUtils.CreateField("FIELD2", esriFieldType.esriFieldTypeInteger);
IField field3 = FieldUtils.CreateField("FIELD3", esriFieldType.esriFieldTypeInteger);
((IFieldEdit)field1).Domain_2 = domain1;
((IFieldEdit)field2).Domain_2 = domain2;
((IFieldEdit)field3).Domain_2 = domain2;
// reuse domain2 - to test if error is reported only once
ITable table = DatasetUtils.CreateTable(_workspace,
MethodBase.GetCurrentMethod().Name,
FieldUtils.CreateOIDField(),
field1, field2, field3);
const int maxLength = 10;
const int minimumValueCount = 1;
const int minimumNonEqualNameValueCount = 1;
const bool allowEmptyName = false;
var runner = new QaTestRunner(new QaSchemaFieldDomainCodedValues(
table, maxLength,
UniqueStringsConstraint.UniqueAnyCase,
minimumValueCount, minimumNonEqualNameValueCount,
allowEmptyName));
runner.Execute();
Assert.AreEqual(2, runner.Errors.Count);
}
public void CanCheckIntsMultiPgdbTable()
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField("UUID",
esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(_pgdbWorkspace,
"CanCheckGuids1", fields);
fields.AddField(FieldUtils.CreateField("UUID2",
esriFieldType.esriFieldTypeInteger));
ITable table2 = TestWorkspaceUtils.CreateSimpleTable(_pgdbWorkspace,
"CanCheckGuids2", fields);
IRow row;
for (var i = 0; i < 10; i++)
{
row = table.CreateRow();
row.set_Value(1, i);
row.Store();
}
row = table2.CreateRow();
row.set_Value(2, 7);
row.Store();
//IWorkspace ws = TestDataUtils.OpenTopgisTlm();
//ITable table = ((IFeatureWorkspace) ws).OpenTable("TOPGIS_TLM.TLM_STRASSE");
var test = new QaUnique(new[] { table, table2 }, new[] { "UUID", "UUID2" });
var runner = new QaTestRunner(test);
runner.Execute();
Assert.AreEqual(2, runner.Errors.Count);
}
private static void TestRelGroupContraints(IFeatureWorkspace ws)
{
ITable tableData =
DatasetUtils.CreateTable(ws, "TblData1",
FieldUtils.CreateOIDField(),
FieldUtils.CreateField("GroupField",
esriFieldType
.esriFieldTypeInteger));
ITable tableRel = DatasetUtils.CreateTable(ws, "TblRel1",
FieldUtils.CreateOIDField(),
FieldUtils.CreateTextField(
"Kostenstelle", 20));
IRelationshipClass rel = TestWorkspaceUtils.CreateSimple1NRelationship(
ws, "rel", tableRel, tableData, "ObjectId", "GroupField");
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
for (int i = 0; i < 20; i++)
{
IRow row = tableData.CreateRow();
row.set_Value(1, 1);
row.Store();
}
for (int i = 0; i < 40; i++)
{
IRow row = tableData.CreateRow();
row.set_Value(1, 2);
row.Store();
}
for (int i = 0; i < 30; i++)
{
IRow row = tableData.CreateRow();
row.set_Value(1, 3);
row.Store();
}
IRow row1 = tableRel.CreateRow();
row1.set_Value(1, "123456-10");
row1.Store();
IRow row2 = tableRel.CreateRow();
row2.set_Value(1, "123456-11");
row2.Store();
IRow row3 = tableRel.CreateRow();
row3.set_Value(1, "123456-12");
row3.Store();
const bool limitToTestedRows = false;
ITable relTab = TableJoinUtils.CreateQueryTable(rel, JoinType.InnerJoin);
var test = new QaGroupConstraints(relTab,
"IIF(LEN(TblRel1.Kostenstelle) >=6, SUBSTRING(TblRel1.Kostenstelle, 1, 6), '')",
"SUBSTRING(TblRel1.Kostenstelle, 8, 9)", 1,
limitToTestedRows);
test.SetRelatedTables(new[] { tableData, tableRel });
using (var runner = new QaTestRunner(test))
{
runner.Execute();
Assert.AreEqual(1, runner.Errors.Count);
}
var containerRunner = new QaContainerTestRunner(100, test);
containerRunner.Execute();
Assert.AreEqual(1, containerRunner.Errors.Count);
}
public IField CreateField()
{
return(Type == esriFieldType.esriFieldTypeString
? FieldUtils.CreateTextField(Name, Length, AliasName)
: FieldUtils.CreateField(Name, Type, AliasName));
}
public void CanIgnoreArea()
{
IFeatureWorkspace ws = TestWorkspaceUtils.CreateInMemoryWorkspace("ignoreArea");
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField("Objektart",
esriFieldType.esriFieldTypeInteger));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000));
IFeatureClass lineFc = DatasetUtils.CreateSimpleFeatureClass(ws, "lineFc", fields);
fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField("Objektart",
esriFieldType.esriFieldTypeInteger));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolygon,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000));
IFeatureClass areaFc = DatasetUtils.CreateSimpleFeatureClass(ws, "areaFc", fields);
fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField("Objektart",
esriFieldType.esriFieldTypeInteger));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolygon,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000));
IFeatureClass ignoreFc = DatasetUtils.CreateSimpleFeatureClass(ws, "ignoreFc", fields);
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
Create(lineFc, 10, CurveConstruction.StartLine(0, 0)
.LineTo(10, 10)
.Curve);
Create(areaFc, 10, CurveConstruction.StartPoly(1, 1)
.LineTo(2, 1)
.LineTo(2, 2)
.LineTo(1, 2)
.ClosePolygon());
Create(areaFc, 10, CurveConstruction.StartPoly(6, 6)
.LineTo(7, 6)
.LineTo(7, 7)
.LineTo(6, 7)
.ClosePolygon());
Create(ignoreFc, 0, CurveConstruction.StartPoly(1, 1)
.LineTo(2, 1)
.LineTo(2, 2)
.LineTo(1, 2)
.ClosePolygon());
Create(ignoreFc, 10, CurveConstruction.StartPoly(6, 6)
.LineTo(7, 6)
.LineTo(7, 7)
.LineTo(6, 7)
.ClosePolygon());
var test = new QaIntersectsOther(lineFc, areaFc);
test.IgnoreArea = ignoreFc;
test.SetConstraint(2, "objektart in (10)");
{
// Container test
var runner = new QaContainerTestRunner(1000, test);
int errorCount = runner.Execute();
Assert.AreEqual(
1, errorCount); // only line errors, point error is removed by test container!
}
{
// simple test
var runner = new QaTestRunner(test);
int errorCount = runner.Execute();
Assert.AreEqual(2, errorCount); // line AND point errors!
}
}
private static void CanDetectNtoMNonUnique([NotNull] IFeatureWorkspace ws)
{
const string uniqueFieldName = "FIELD_UNIQUE";
const string foreignKeyFieldName = "FOREIGN_KEY_FIELD";
const string origTableName = "OrigTable2";
const string destTableName = "DestTable2";
ITable originTable;
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField(uniqueFieldName,
esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(
ws, origTableName, fields);
originTable = table;
}
ITable destinationTable;
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField(
foreignKeyFieldName, esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(
ws, destTableName, fields);
destinationTable = table;
}
IRelationshipClass relClass = TestWorkspaceUtils.CreateSimpleMNRelationship(
ws, "relNonUnique", originTable, destinationTable,
"OrigFKey", "DestFKey");
{
// insert Data
((IWorkspaceEdit)ws).StartEditing(false);
for (var i = 0; i < 10; i++)
{
IRow row = originTable.CreateRow();
row.set_Value(1, i);
row.Store();
}
for (var i = 0; i < 10; i++)
{
IRow row = destinationTable.CreateRow();
row.set_Value(1, i);
row.Store();
relClass.CreateRelationship((IObject)originTable.GetRow(i + 1),
(IObject)row);
}
{
IRow row = destinationTable.CreateRow();
row.set_Value(1, 5);
row.Store();
relClass.CreateRelationship((IObject)originTable.GetRow(5 + 1),
(IObject)row);
}
{
IRow row = destinationTable.CreateRow();
row.set_Value(1, 5);
row.Store();
relClass.CreateRelationship((IObject)originTable.GetRow(5 + 1),
(IObject)row);
}
{
IRow row = destinationTable.CreateRow();
row.set_Value(1, 7);
row.Store();
relClass.CreateRelationship((IObject)originTable.GetRow(7 + 1),
(IObject)row);
}
((IWorkspaceEdit)ws).StopEditing(true);
}
ITable relTab = TableJoinUtils.CreateQueryTable(relClass, JoinType.InnerJoin);
foreach (bool forceInMemoryTableSort in new[] { true, false })
{
var test = new QaUnique(relTab, origTableName + "." + uniqueFieldName)
{
ForceInMemoryTableSorting = forceInMemoryTableSort
};
test.SetRelatedTables(new[] { originTable, destinationTable });
var runner = new QaTestRunner(test);
runner.Execute();
Assert.AreEqual(5, runner.Errors.Count);
}
}
private static ITable CanDetect1toNNonUnique([NotNull] IFeatureWorkspace workspace)
{
ITable tableOrig;
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField(
"Unique", esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(
workspace, "Relate1NNonUnique1", 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, "Relate1NNonUnique2", fields);
for (var i = 0; i < 10; i++)
{
IRow row = table.CreateRow();
row.set_Value(1, i);
row.Store();
}
{
IRow row = table.CreateRow();
row.set_Value(1, 5);
row.Store();
}
{
IRow row = table.CreateRow();
row.set_Value(1, 5);
row.Store();
}
{
IRow row = table.CreateRow();
row.set_Value(1, 7);
row.Store();
}
tableRel = table;
}
IRelationshipClass rel = TestWorkspaceUtils.CreateSimple1NRelationship(
workspace, "rel1NNonUnique", tableOrig, tableRel, "Unique", "Ref");
ITable relTab = TableJoinUtils.CreateQueryTable(rel, JoinType.InnerJoin);
foreach (bool forceInMemoryTableSort in new[] { true, false })
{
var test = new QaUnique(relTab, "Relate1NNonUnique1.Unique")
{
ForceInMemoryTableSorting = forceInMemoryTableSort
};
test.SetRelatedTables(new[] { tableOrig, tableRel });
var runner = new QaTestRunner(test);
runner.Execute();
Assert.AreEqual(5, runner.Errors.Count);
}
return(relTab);
}
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 DuplicatesInOtherWorkspace()
{
IDomain domain1 = DomainUtils.AddDomain(_workspace,
DomainUtils.CreateCodedValueDomain(
"DOM_FIELD1",
esriFieldType.esriFieldTypeInteger,
"Description of DOM_FIELD1",
new CodedValue(1, "Value 1"),
new CodedValue(2, "Value 2")));
IDomain domain2 = DomainUtils.AddDomain(_workspace,
DomainUtils.CreateCodedValueDomain(
"DOM_FIELD2",
esriFieldType.esriFieldTypeInteger,
"Description of DOM_FIELD2",
new CodedValue(1, "Value 1"),
new CodedValue(2, "Value 2")));
// domain (not used in table) with duplicate name - this should not be reported since duplicates are searched in target (?)
DomainUtils.AddDomain(_workspace,
DomainUtils.CreateCodedValueDomain("DOM_FIELD3",
esriFieldType
.esriFieldTypeInteger,
"Description of DOM_FIELD2",
new CodedValue(1,
"Value 1"),
new CodedValue(2,
"Value 2")));
IField field1 = FieldUtils.CreateField("FIELD1", esriFieldType.esriFieldTypeInteger);
IField field2 = FieldUtils.CreateField("FIELD2", esriFieldType.esriFieldTypeInteger);
IField field3 = FieldUtils.CreateTextField("FIELD3", 20);
((IFieldEdit)field1).Domain_2 = domain1;
((IFieldEdit)field2).Domain_2 = domain2;
ITable table = DatasetUtils.CreateTable(_workspace,
MethodBase.GetCurrentMethod().Name,
FieldUtils.CreateOIDField(),
field1, field2, field3);
// add domains/table to target workspace
IFeatureWorkspace targetWorkspace =
TestWorkspaceUtils.CreateTestFgdbWorkspace($"{GetType().Name}_target");
// same name, same description --> should be considered equal, no duplicate
DomainUtils.AddDomain(targetWorkspace,
DomainUtils.CreateCodedValueDomain("DOM_FIELD1",
esriFieldType
.esriFieldTypeInteger,
"Description of DOM_FIELD1",
new CodedValue(1,
"Value 1"),
new CodedValue(2,
"Value 2")));
// different name, same description --> should be reported
DomainUtils.AddDomain(targetWorkspace,
DomainUtils.CreateCodedValueDomain("DOM_FIELD4",
esriFieldType
.esriFieldTypeInteger,
"Description of DOM_FIELD2",
new CodedValue(1,
"Value 1"),
new CodedValue(2,
"Value 2")));
// different name, same description --> should be reported
DomainUtils.AddDomain(targetWorkspace,
DomainUtils.CreateRangeDomain("DOM_FIELD5",
esriFieldType.esriFieldTypeInteger,
0, 100,
"Description of DOM_FIELD2"));
ITable targetTable = DatasetUtils.CreateTable(targetWorkspace,
MethodBase.GetCurrentMethod().Name,
FieldUtils.CreateOIDField(),
FieldUtils.CreateTextField("FIELD1",
10));
const int maxLength = 25;
const bool noDuplicates = true;
var runner =
new QaTestRunner(new QaSchemaFieldDomainDescriptions(table, maxLength,
noDuplicates,
targetTable));
runner.Execute();
Assert.AreEqual(1, runner.Errors.Count);
}
public static GdbTable FromObjectClassMsg(
[NotNull] ObjectClassMsg objectClassMsg,
[CanBeNull] IWorkspace workspace,
[CanBeNull] Func <ITable, BackingDataset> createBackingDataset = null)
{
esriGeometryType geometryType = (esriGeometryType)objectClassMsg.GeometryType;
GdbTable result;
if (geometryType == esriGeometryType.esriGeometryNull)
{
result = new GdbTable(objectClassMsg.ClassHandle,
objectClassMsg.Name, objectClassMsg.Alias,
createBackingDataset, workspace);
}
else
{
result = new GdbFeatureClass(
objectClassMsg.ClassHandle,
objectClassMsg.Name,
(esriGeometryType)objectClassMsg.GeometryType,
objectClassMsg.Alias,
createBackingDataset, workspace)
{
SpatialReference =
ProtobufGeometryUtils.FromSpatialReferenceMsg(
objectClassMsg.SpatialReference)
};
}
if (objectClassMsg.Fields == null || objectClassMsg.Fields.Count <= 0)
{
return(result);
}
foreach (FieldMsg fieldMsg in objectClassMsg.Fields)
{
IField field = FieldUtils.CreateField(fieldMsg.Name,
(esriFieldType)fieldMsg.Type,
fieldMsg.AliasName);
if (field.Type == esriFieldType.esriFieldTypeString)
{
((IFieldEdit)field).Length_2 = fieldMsg.Length;
}
else if (field.Type == esriFieldType.esriFieldTypeGeometry)
{
var sr = ProtobufGeometryUtils.FromSpatialReferenceMsg(
objectClassMsg.SpatialReference);
field = FieldUtils.CreateShapeField(geometryType, sr, 1000, true, false);
}
if (result.Fields.FindField(field.Name) < 0)
{
result.AddField(field);
}
else
{
_msg.DebugFormat("Field {0} is duplicate or has been added previously",
field.Name);
}
}
return(result);
}
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);
}
}
private void TestFlowDirMultiExpression(IFeatureWorkspace ws)
{
IFeatureClass fc1;
{
var fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField("FlowDir",
esriFieldType.esriFieldTypeInteger));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000));
fc1 = DatasetUtils.CreateSimpleFeatureClass(ws,
"TestFlowDirMultiExpression1",
fields);
}
IFeatureClass fc2;
{
var fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField("FlowDir",
esriFieldType.esriFieldTypeInteger));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000));
fc2 = DatasetUtils.CreateSimpleFeatureClass(ws,
"TestFlowDirMultiExpression2",
fields);
}
// make sure the tables are known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
{
IFeature row = fc1.CreateFeature();
row.set_Value(1, 5);
row.Shape =
GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(100, 200),
GeometryFactory.CreatePoint(110, 190));
row.Store();
}
{
IFeature row = fc2.CreateFeature();
row.set_Value(1, 5);
row.Shape =
GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(120, 190),
GeometryFactory.CreatePoint(110, 190));
row.Store();
}
{
IFeature row = fc1.CreateFeature();
row.set_Value(1, null);
row.Shape =
GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(120, 190),
GeometryFactory.CreatePoint(130, 190));
row.Store();
}
{
var test = new QaFlowLogic(
new[] { fc1, fc2 },
new[] { "FlowDir > 6", "FlowDir < 6" }
// no feature fc1 will be inverted, feature of fc2 will be inverted
);
test.QaError += Test_QaError;
_errorCount = 0;
test.Execute();
Assert.AreEqual(1, _errorCount);
test.QaError -= Test_QaError;
var container = new TestContainer();
container.AddTest(test);
_errorCount = 0;
container.QaError += Test_QaError;
container.Execute();
Assert.AreEqual(1, _errorCount);
}
{
var test = new QaFlowLogic(
new[] { fc1, fc2 },
new[] { "FlowDir > 6" }
// no feature will be inverted
);
test.QaError += Test_QaError;
_errorCount = 0;
test.Execute();
Assert.AreEqual(3, _errorCount);
test.QaError -= Test_QaError;
var container = new TestContainer();
container.AddTest(test);
container.QaError += Test_QaError;
_errorCount = 0;
container.Execute();
Assert.AreEqual(3, _errorCount);
}
}
private void TestFlowDirExpression(IFeatureWorkspace ws)
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField("FlowDir",
esriFieldType.esriFieldTypeInteger));
fields.AddField(FieldUtils.CreateShapeField(
"Shape", esriGeometryType.esriGeometryPolyline,
SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true), 1000));
IFeatureClass featureClass =
DatasetUtils.CreateSimpleFeatureClass(ws, "TestFlowDirExpression", fields);
// make sure the table is known by the workspace
((IWorkspaceEdit)ws).StartEditing(false);
((IWorkspaceEdit)ws).StopEditing(true);
{
IFeature row = featureClass.CreateFeature();
row.set_Value(1, 5);
row.Shape =
GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(100, 200),
GeometryFactory.CreatePoint(110, 190));
row.Store();
}
{
IFeature row = featureClass.CreateFeature();
row.set_Value(1, 10);
row.Shape =
GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(120, 190),
GeometryFactory.CreatePoint(110, 190));
row.Store();
}
IPoint lastPoint;
{
IFeature row = featureClass.CreateFeature();
row.set_Value(1, null);
row.Shape =
GeometryFactory.CreateLine(
GeometryFactory.CreatePoint(120, 190),
GeometryFactory.CreatePoint(130, 190));
row.Store();
lastPoint = ((IPolyline)row.Shape).ToPoint;
}
var test = new QaFlowLogic(new[] { featureClass }, new[] { "FlowDir > 6" });
test.QaError += Test_QaError;
_errorCount = 0;
test.Execute();
Assert.AreEqual(1, _errorCount);
Assert.AreEqual(lastPoint.X, _lastErrorPoint.X);
Assert.AreEqual(lastPoint.Y, _lastErrorPoint.Y);
test.QaError -= Test_QaError;
var container = new TestContainer();
container.AddTest(test);
container.QaError += Test_QaError;
_errorCount = 0;
container.Execute();
Assert.AreEqual(1, _errorCount);
Assert.AreEqual(lastPoint.X, _lastErrorPoint.X);
Assert.AreEqual(lastPoint.Y, _lastErrorPoint.Y);
}
