public void AddingIntsTest()
{
var set = new SimpleSet <int> {
1, 2, 3
};
Assert.AreEqual(3, set.Count);
Assert.IsTrue(set.Contains(1));
Assert.IsTrue(set.Contains(2));
Assert.IsTrue(set.Contains(3));
Assert.IsFalse(set.Contains(4));
}
private static IEnumerable <Dataset> GetVerifiedDatasets(
[NotNull] QualitySpecification qualitySpecification,
[NotNull] IDatasetContext datasetContext)
{
var datasets = new SimpleSet <Dataset>();
foreach (
QualitySpecificationElement qualitySpecificationElement in
qualitySpecification.Elements)
{
QualityCondition qualityCondition = qualitySpecificationElement.QualityCondition;
if (qualityCondition == null)
{
continue;
}
foreach (Dataset dataset in qualityCondition.GetDatasetParameterValues())
{
if (!datasets.Contains(dataset) && datasetContext.CanOpen(dataset))
{
datasets.Add(dataset);
}
}
}
return(datasets);
}
public void ReferenceEqualityTest()
{
var set = new SimpleSet <TestMember>();
var theObject = new TestMember("hello");
var equalObject = new TestMember("HELLO");
Assert.IsTrue(theObject.Equals(equalObject));
Assert.IsFalse(theObject == equalObject);
set.Add(theObject);
TestMember containedObject;
bool isContained = set.Contains(equalObject, out containedObject);
Assert.IsTrue(isContained);
Assert.IsTrue(containedObject.Equals(equalObject));
Assert.IsTrue(containedObject == theObject);
Assert.IsTrue(containedObject != equalObject);
bool isChanged = set.TryAdd(equalObject, out containedObject);
Assert.IsFalse(isChanged);
Assert.IsTrue(containedObject.Equals(equalObject));
Assert.IsTrue(containedObject == theObject);
Assert.IsTrue(containedObject != equalObject);
TestMember removedObject;
bool wasContained = set.Remove(equalObject, out removedObject);
Assert.IsTrue(wasContained);
Assert.IsTrue(removedObject.Equals(theObject));
Assert.IsTrue(removedObject == theObject);
Assert.IsTrue(removedObject != equalObject);
}
public bool AreAllDatasetsEditable([NotNull] ICollection <Dataset> datasets)
{
if (EditableDatasetCount != datasets.Count)
{
// count is different
return(false);
}
if (_editableDatasets == null)
{
// both collections are empty
return(true);
}
// check if all datasets from the list are contained
return(datasets.All(dataset => _editableDatasets.Contains(dataset.Name)));
}
public void AddingContainedElementThrowsException()
{
var set = new SimpleSet <object>();
var member = new TestMember("hello");
set.Add(member);
Assert.Catch(() => set.Add(member));
Assert.True(set.Contains(member));
}
public void CannotAddNull()
{
var set = new SimpleSet <object>();
set.Add("cannot");
set.Add("add");
Assert.Catch <ArgumentNullException>(() => set.Add(null));
// but can test for null: it's always false
Assert.False(set.Contains(null));
}
private int CheckDuplicateDescriptions(
[NotNull] IEnumerable <DomainUsage> domainUsages)
{
Assert.ArgumentNotNull(domainUsages, nameof(domainUsages));
IWorkspace targetWorkspace =
DatasetUtils.GetWorkspace(_targetWorkspaceTable ?? _table);
// TODO also search for duplicates in the source workspace? Or would this be a separate test instance?
Dictionary <string, List <IDomain> > domainsByDescription =
GetDomainsByDescription(targetWorkspace);
var descriptions = new SimpleSet <string>(StringComparer.InvariantCultureIgnoreCase);
foreach (DomainUsage domainUsage in domainUsages)
{
string description = domainUsage.Domain.Description;
if (description != null && !descriptions.Contains(description))
{
descriptions.Add(description);
}
}
int errorCount = 0;
foreach (string domainDescription in descriptions)
{
List <IDomain> domainsWithSameDescription;
if (!domainsByDescription.TryGetValue(domainDescription,
out domainsWithSameDescription))
{
continue;
}
if (domainsWithSameDescription.Count <= 1)
{
continue;
}
string description =
string.Format(
LocalizableStrings
.QaSchemaFieldDomainDescriptions_DomainDescriptionNotUnique,
domainDescription,
StringUtils.Concatenate(GetDomainNames(domainsWithSameDescription), ", "));
errorCount += ReportSchemaError(Codes[Code.NotUnique], description);
}
return(errorCount);
}
private int CheckUniqueNames([NotNull] DomainUsage domainUsage,
[NotNull] ICollection <CodedValue> codedValues)
{
SimpleSet <string> uniqueNames = CreateUniqueNamesSet(_uniqueNamesConstraint);
if (uniqueNames == null)
{
return(NoError);
}
var nonUniqueNames = new List <string>();
foreach (CodedValue codedValue in codedValues)
{
// gather non-unique names, uniqueness check will be done at end
string name = codedValue.Name.Trim();
if (uniqueNames.Contains(name))
{
nonUniqueNames.Add(name);
}
else
{
uniqueNames.Add(name);
}
}
bool caseSensitive = _uniqueNamesConstraint ==
UniqueStringsConstraint.UniqueExactCase;
int errorCount = 0;
foreach (string nonUniqueName in nonUniqueNames)
{
string description =
string.Format(
"Name '{0}' in coded value domain '{1}' is non-unique. The following values have the same name: {2}",
nonUniqueName, domainUsage.DomainName,
StringUtils.Concatenate(
GetValuesForName(nonUniqueName, codedValues, caseSensitive), ", "));
errorCount += ReportSchemaPropertyError(Codes[Code.NamesNotUnique],
domainUsage.DomainName,
new object[] { nonUniqueName },
description);
}
return(errorCount);
}
public bool Contains([NotNull] QualityCondition qualityCondition)
{
if (_qualityConditions == null)
{
IList <QualitySpecificationElement> elements = _qualitySpecification.Elements;
_qualityConditions = new SimpleSet <QualityCondition>(elements.Count);
foreach (QualitySpecificationElement element in elements)
{
_qualityConditions.Add(element.QualityCondition);
}
}
return(_qualityConditions.Contains(qualityCondition));
}
public void AddIssue(Issue issue, IGeometry errorGeometry)
{
QualityCondition qualityCondition = issue.QualityCondition;
if (_processedQualityConditions.Contains(qualityCondition.Name))
{
return;
}
_processedQualityConditions.Add(qualityCondition.Name);
foreach (Dataset dataset in qualityCondition.GetDatasetParameterValues())
{
_involvedDatasets.TryAdd(dataset);
}
}
private static void AssertUniqueFieldNames(
[NotNull] IEnumerable <FieldSpecification> fieldSpecifications)
{
var fieldNames = new SimpleSet <string>(StringComparer.InvariantCultureIgnoreCase);
foreach (FieldSpecification fieldSpecification in fieldSpecifications)
{
if (fieldNames.Contains(fieldSpecification.FieldName))
{
Assert.Fail(
"There exists more than one field specification for field name '{0}'",
fieldSpecification.FieldName);
}
fieldNames.Add(fieldSpecification.FieldName);
}
}
private static SortableBindingList <VerifiedDatasetItem> GetVerifiedDatasetItems(
[NotNull] QualityVerification qualityVerification,
[NotNull] Predicate <QualityConditionVerification> includeConditionVerification,
out double maximumTime)
{
var result = new SortableBindingList <VerifiedDatasetItem>();
maximumTime = 0;
foreach (
QualityConditionVerification conditionVerification in
qualityVerification.ConditionVerifications)
{
if (!includeConditionVerification(conditionVerification))
{
continue;
}
var datasets = new SimpleSet <Dataset>();
QualityCondition condition = conditionVerification.DisplayableCondition;
foreach (Dataset dataset in condition.GetDatasetParameterValues())
{
if (datasets.Contains(dataset))
{
continue;
}
datasets.Add(dataset);
VerifiedDatasetItem item = CreateVerifiedDatasetItem(
qualityVerification, dataset,
conditionVerification);
if (item.TotalTime > maximumTime)
{
maximumTime = item.TotalTime;
}
result.Add(item);
}
}
return(result);
}
private static IEnumerable <int> GetFieldIndicesFromIgnoredFieldNames(
[NotNull] ITable table,
[NotNull] IEnumerable <string> ignoredFieldNames)
{
var ignoredFields = new SimpleSet <string>(
ignoredFieldNames, StringComparer.InvariantCultureIgnoreCase);
int fieldIndex = 0;
foreach (IField field in DatasetUtils.GetFields(table))
{
if (field.Type == esriFieldType.esriFieldTypeString &&
!ignoredFields.Contains(field.Name))
{
yield return(fieldIndex);
}
fieldIndex++;
}
}
private static IEnumerable <int> GetCompareFieldIndexesFromIgnoredFieldNames(
[NotNull] IObjectClass objectClass,
[NotNull] IEnumerable <string> ignoredFieldNames)
{
var ignoredFields = new SimpleSet <string>(
ignoredFieldNames, StringComparer.InvariantCultureIgnoreCase);
var fieldIndex = 0;
foreach (IField field in DatasetUtils.GetFields(objectClass))
{
if (field.Editable &&
IsSupportedCompareFieldType(field.Type) &&
!ignoredFields.Contains(field.Name))
{
yield return(fieldIndex);
}
fieldIndex++;
}
}
