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++; } }