public void SetQualityCondition([CanBeNull] QualityCondition qualityCondition)
{
_testDescriptor = null;
var paramValues = new BindingList <ParameterValueListItem>();
if (qualityCondition != null)
{
_testDescriptor = qualityCondition.TestDescriptor;
var paramDictionary = new Dictionary <string, List <TestParameterValue> >();
foreach (TestParameterValue paramValue in qualityCondition.ParameterValues)
{
List <TestParameterValue> valueList;
if (!paramDictionary.TryGetValue(paramValue.TestParameterName, out valueList))
{
valueList = new List <TestParameterValue>();
paramDictionary.Add(paramValue.TestParameterName, valueList);
}
valueList.Add(paramValue);
}
foreach (List <TestParameterValue> valueList in paramDictionary.Values)
{
foreach (TestParameterValue paramValue in valueList)
{
paramValues.Add(new ParameterValueListItem(paramValue));
}
}
}
BindToParameterValues(paramValues);
ShowDescription = true;
}
public override string Export(QualityCondition qualityCondition)
{
LineNotNearPolyOverlapConfigurator.Matrix matrix =
LineNotNearPolyOverlapConfigurator.Convert(qualityCondition);
return(matrix.ToCsv());
}
public VerifiedConditionItem(
[NotNull] QualityConditionVerification qualityConditionVerification)
{
Assert.ArgumentNotNull(qualityConditionVerification,
nameof(qualityConditionVerification));
QualityConditionVerification = qualityConditionVerification;
QualityCondition qualityCondition =
Assert.NotNull(qualityConditionVerification.DisplayableCondition);
TestDescriptor testDescriptor = qualityCondition.TestDescriptor;
Name = qualityCondition.Name;
Category = qualityCondition.Category?.GetQualifiedName();
TestDescriptorName = testDescriptor.Name;
TestCategories = GetTestCategories(testDescriptor);
DatasetNames = GetDatasetNames(qualityCondition);
IssueCount = qualityConditionVerification.ErrorCount;
IssueType = qualityConditionVerification.AllowErrors
? IssueType.Warning
: IssueType.Error;
StatusImage = IssueCount == 0
? _statusImageNoIssues
: qualityConditionVerification.AllowErrors
? _statusImageHasWarnings
: _statusImageHasErrors;
}
private static HashSet <IObjectDataset> GetIgnoredObjectDatasets(
[NotNull] QualityCondition qualityCondition,
[CanBeNull] InvolvedObjectsMatchCriteria criteria)
{
if (criteria == null)
{
return(null);
}
HashSet <IObjectDataset> result = null;
foreach (Dataset dataset in qualityCondition.GetDatasetParameterValues())
{
var objectDataset = dataset as IObjectDataset;
if (objectDataset == null || !criteria.IgnoreDataset(objectDataset))
{
continue;
}
if (result == null)
{
result = new HashSet <IObjectDataset>();
}
result.Add(objectDataset);
}
return(result);
}
public override string Export(QualityCondition qualityCondition)
{
var config = new DatasetConstraintConfigurator(
qualityCondition.ParameterValues);
return(config.ToCsv());
}
/// <summary>
/// Adds an error to the error repository. Call <see cref="SavePendingErrors"/> to
/// save all the pending errors added to the repository.
/// </summary>
/// <param name="qaError"></param>
/// <param name="qualityCondition"></param>
/// <param name="isAllowable"></param>
public void AddError([NotNull] QaError qaError,
[NotNull] QualityCondition qualityCondition,
bool isAllowable)
{
Assert.ArgumentNotNull(qaError, nameof(qaError));
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
IssueDatasetWriter issueWriter = PrepareIssueWriter(qaError, qualityCondition,
isAllowable);
try
{
issueWriter.InsertRow();
}
catch (IssueFeatureInsertionFailedException)
{
_msg.Warn(
"Unable to write issue feature (see log for details); trying again with simplified issue geometry");
// the geometry was probably non-simple enough for the insert to fail
// -> try again with forced simplification of issue geometry
issueWriter = PrepareIssueWriter(qaError, qualityCondition, isAllowable,
forceSimplify: true);
// give up if this fails also
issueWriter.InsertRow();
}
}
private IssueDatasetWriter PrepareIssueWriter(
[NotNull] QaError qaError,
[NotNull] QualityCondition qualityCondition,
bool isAllowable,
bool forceSimplify = false)
{
// create valid Error geometry (geometry type, min dimensions) if possible
IGeometry geometry = ErrorRepositoryUtils.GetGeometryToStore(
qaError.Geometry,
IssueDatasets.SpatialReference,
IssueDatasets.GetIssueWritersByGeometryType().Keys,
_isPre10Geodatabase,
forceSimplify);
IssueDatasetWriter issueWriter = IssueDatasets.GetIssueWriter(geometry);
IRowBuffer rowBuffer = issueWriter.GetRowBuffer();
// write geometry to the buffer
if (geometry != null)
{
// update the geometry directly if needed (it is already a copy)
GeometryUtils.EnsureSchemaZM(geometry, issueWriter.HasZ, issueWriter.HasM);
WriteGeometry(geometry, (IFeatureBuffer)rowBuffer);
}
IList <ITest> tests = _testsByQualityCondition[qualityCondition];
WriteAttributes(issueWriter, rowBuffer, qualityCondition, isAllowable,
qaError, tests);
return(issueWriter);
}
public bool IsDeletable(IRow errorRow,
QualityCondition qualityCondition)
{
var hasUnknownTables = false;
foreach (InvolvedRow involvedRow in _issueWriter.GetInvolvedRows(errorRow))
{
bool tableIsUnknown;
if (_objectSelection.Contains(involvedRow, qualityCondition, out tableIsUnknown)
)
{
return(true);
}
if (tableIsUnknown)
{
hasUnknownTables = true;
}
}
if (hasUnknownTables)
{
// TODO delete?
}
return(false);
}
void IExceptionEvaluationStatistics.AddExceptionObject(
ExceptionObject exceptionObject, QualityCondition qualityCondition)
{
ExceptionObjectCount++;
GetStatistics(qualityCondition).AddExceptionObject(exceptionObject);
}
public AllowedError([NotNull] QualityCondition qualityCondition,
int?conditionVersion,
[CanBeNull] IGeometry geometry,
[NotNull] string errorDescription,
[NotNull] IList <InvolvedRow> involvedRows,
[NotNull] ITable table,
int objectId,
DateTime dateOfCreation,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver)
{
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
Assert.ArgumentNotNull(errorDescription, nameof(errorDescription));
Assert.ArgumentNotNull(involvedRows, nameof(involvedRows));
Assert.ArgumentNotNull(table, nameof(table));
Assert.ArgumentNotNull(datasetResolver, nameof(datasetResolver));
_qualityCondition = qualityCondition;
_qualityConditionVersion = conditionVersion;
_errorDescription = errorDescription;
_involvedRows = involvedRows;
_errorGeometry = new QaErrorGeometry(geometry);
_table = table;
_oid = objectId;
_dateOfCreation = dateOfCreation;
_datasetResolver = datasetResolver;
_isUsed = false;
_invalidated = false;
_usesGdbDatasetNames = false; // uses involved row table name
}
private static IObject GetInvolvedObject(
[NotNull] InvolvedRow involvedRow,
[NotNull] QualityCondition qualityCondition,
[NotNull] IDatasetContext datasetContext,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[NotNull] out IObjectDataset objectDataset)
{
Assert.ArgumentNotNull(involvedRow, nameof(involvedRow));
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
Assert.ArgumentCondition(!involvedRow.RepresentsEntireTable,
"involved row represents entire table");
Assert.ArgumentNotNull(datasetContext, nameof(datasetContext));
//string gdbTableName = involvedRow.TableName;
//objectDataset = Assert.NotNull(
// QualityVerificationUtils.GetInvolvedObjectDataset(gdbTableName,
// qualityCondition,
// datasetResolver),
// "object dataset not found for {0}", involvedRow.TableName);
string gdbTableName = involvedRow.TableName;
objectDataset = Assert.NotNull(
datasetResolver.GetDatasetByGdbTableName(gdbTableName, qualityCondition),
"object dataset not found for {0}", involvedRow.TableName);
ITable table = datasetContext.OpenTable(objectDataset);
// TODO REFACTORMODEL revise null handling
Assert.NotNull(table, "Dataset not found in workspace: {0}", objectDataset.Name);
// TODO batch!
return((IObject)table.GetRow(involvedRow.OID));
}
public IObjectDataset GetDatasetByGdbTableName(
string gdbTableName, QualityCondition qualityCondition)
{
Assert.ArgumentNotNullOrEmpty(gdbTableName, nameof(gdbTableName));
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
Dictionary <string, Dataset> datasetsByGdbTableName;
if (!_gdbDatasetMap.TryGetValue(qualityCondition, out datasetsByGdbTableName))
{
datasetsByGdbTableName = new Dictionary <string, Dataset>(
StringComparer.OrdinalIgnoreCase);
_gdbDatasetMap.Add(qualityCondition, datasetsByGdbTableName);
}
Dataset dataset;
if (!datasetsByGdbTableName.TryGetValue(gdbTableName, out dataset))
{
dataset = GetDatasetByGdbTableNameCore(gdbTableName, qualityCondition);
// can be null
datasetsByGdbTableName.Add(gdbTableName, dataset);
}
return(dataset as IObjectDataset);
}
private static bool ExcludeDependenciesWithinMultiValuedParameter(
[NotNull] QualityCondition qualityCondition,
[NotNull] string testParameterName)
{
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
Assert.ArgumentNotNullOrEmpty(testParameterName, nameof(testParameterName));
TestDescriptor testDescriptor = qualityCondition.TestDescriptor;
if (testDescriptor == null)
{
return(false);
}
ClassDescriptor testClass = testDescriptor.TestClass;
if (testClass != null)
{
if (testClass.TypeName.EndsWith("Other", StringComparison.OrdinalIgnoreCase))
{
// naming convention: for "...Other" tests there is no dependency *within" each list parameter
return(true);
}
// TODO handle specific tests
return(false);
}
return(false);
}
private static string GetDescription([NotNull] QualityCondition condition)
{
string description;
if (string.IsNullOrEmpty(condition.Description))
{
TestDescriptor testDescriptor = condition.TestDescriptor;
ITestImplementationInfo testImplementationInfo =
testDescriptor == null
? null
: TestDescriptorUtils.GetTestImplementationInfo(testDescriptor);
description = testImplementationInfo == null
? string.Empty
: testImplementationInfo.GetTestDescription();
}
else
{
description = condition.Description;
}
if (description == null)
{
return(string.Empty);
}
description = description.Replace("\r", string.Empty);
description = description.Replace("\n", Environment.NewLine);
return(description);
}
private static ICollection <Dataset> GetMissingDatasets(
[NotNull] QualityCondition condition,
[NotNull] IOpenDataset datasetOpener,
[NotNull] ICollection <Dataset> knownMissingDatasets,
[NotNull] ICollection <Dataset> knownExistingDatasets)
{
var result = new List <Dataset>();
foreach (var dataset in condition.GetDatasetParameterValues())
{
if (knownExistingDatasets.Contains(dataset))
{
continue;
}
if (knownMissingDatasets.Contains(dataset))
{
result.Add(dataset);
continue;
}
if (ExistsDataset(dataset, datasetOpener))
{
knownExistingDatasets.Add(dataset);
}
else
{
knownMissingDatasets.Add(dataset);
result.Add(dataset);
}
}
return(result);
}
private static string GetParametersText([NotNull] QualityCondition qualityCondition)
{
var sb = new StringBuilder();
if (qualityCondition.ParameterValues.Count == 1)
{
TestParameterValue parameterValue = qualityCondition.ParameterValues[0];
sb.AppendFormat("parameter {0}", Format(parameterValue));
}
else
{
sb.Append("parameters ");
foreach (TestParameterValue parameterValue in qualityCondition.ParameterValues)
{
if (sb.Length > 0)
{
sb.Append(", ");
}
sb.Append(Format(parameterValue));
}
}
return(sb.ToString());
}
private IEnumerable <ITest> CreateTests(
[NotNull] IEnumerable <QualitySpecificationElement> qualitySpecificationElements,
[CanBeNull] IDatasetContext datasetContext,
out IDictionary <ITest, QualitySpecificationElement> qualityConditionsByTest)
{
var result = new List <ITest>();
qualityConditionsByTest = new Dictionary <ITest, QualitySpecificationElement>();
if (datasetContext == null)
{
return(result);
}
IOpenDataset datasetOpener = _openDatasetFactory(datasetContext);
foreach (QualitySpecificationElement element in qualitySpecificationElements)
{
QualityCondition condition = element.QualityCondition;
TestFactory factory = Assert.NotNull(
TestFactoryUtils.CreateTestFactory(condition),
$"Cannot create test factory for condition {condition.Name}");
foreach (ITest test in factory.CreateTests(datasetOpener))
{
result.Add(test);
qualityConditionsByTest.Add(test, element);
}
}
return(result);
}
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);
}
GetElementsByCategory(
[NotNull] IEnumerable <QualitySpecificationElement> qualitySpecificationElements,
[NotNull] out List <QualitySpecificationElement> elementsWithNoCategory)
{
elementsWithNoCategory = new List <QualitySpecificationElement>();
var result =
new Dictionary <DataQualityCategory, List <QualitySpecificationElement> >();
foreach (QualitySpecificationElement element in qualitySpecificationElements)
{
QualityCondition condition = element.QualityCondition;
DataQualityCategory category = condition.Category;
if (category == null)
{
elementsWithNoCategory.Add(element);
}
else
{
List <QualitySpecificationElement> elements;
if (!result.TryGetValue(category, out elements))
{
elements = new List <QualitySpecificationElement>();
result.Add(category, elements);
}
elements.Add(element);
}
}
return(result);
}
private static ICollection <SpecificationDataset> GetSpecifiations(
[NotNull] IEnumerable <SpecificationDataset> specList,
[NotNull] ICollection <Dataset> parameterDatasets)
{
var result = new List <SpecificationDataset>();
foreach (SpecificationDataset spec in specList)
{
QualityCondition condition = spec.QualityCondition;
if (condition == null)
{
continue;
}
var mustDs = new HashSet <Dataset>(parameterDatasets);
foreach (Dataset dataset in condition.GetDatasetParameterValues())
{
mustDs.Remove(dataset);
}
if (mustDs.Count == 0)
{
result.Add(spec);
}
}
return(result);
}
public static Image GetImage([CanBeNull] QualityCondition qualityCondition)
{
return(qualityCondition == null
? null
: GetImage(qualityCondition.AllowErrors,
qualityCondition.StopOnError));
}
public bool Contains(InvolvedRow involvedRow, QualityCondition qualityCondition,
out bool unknownTable)
{
if (involvedRow.RepresentsEntireTable)
{
unknownTable = false; // does not matter
return(false);
}
IObjectDataset dataset = _datasetResolver.GetDatasetByInvolvedRowTableName(
involvedRow.TableName, qualityCondition);
if (dataset == null)
{
// unable to resolve the dataset
unknownTable = true;
return(false);
}
unknownTable = false;
HashSet <int> objectIds;
return(_objectsByDataset.TryGetValue(dataset, out objectIds) &&
objectIds.Contains(involvedRow.OID));
}
public VerifiedDatasetItem(
[NotNull] QualityConditionVerification conditionVerification,
[NotNull] IDdxDataset dataset,
double loadTime)
{
_conditionVerification = conditionVerification;
QualityCondition condition = conditionVerification.DisplayableCondition;
_type = conditionVerification.AllowErrors
? _allowImage
: !conditionVerification.StopOnError
? _continueImage
: _stopImage;
_status = conditionVerification.ErrorCount == 0
? _noErrorsImage
: conditionVerification.AllowErrors
? _warningImage
: _errorsImage;
_testName = condition.Name;
_testType = condition.TestDescriptor.Name;
_dataLoadTime = loadTime;
_datasetName = dataset.AliasName;
string datasetImageKey = DatasetTypeImageLookup.GetImageKey(dataset);
_datasetType = _datasetImageList[datasetImageKey];
}
private Dataset GetDatasetByModelName(
[NotNull] string datasetModelName,
[NotNull] QualityCondition qualityCondition)
{
Dictionary <string, Dataset> datasetsByModelName;
if (!_modelDatasetMap.TryGetValue(qualityCondition, out datasetsByModelName))
{
datasetsByModelName = new Dictionary <string, Dataset>(
StringComparer.OrdinalIgnoreCase);
_modelDatasetMap.Add(qualityCondition, datasetsByModelName);
}
Dataset result;
if (!datasetsByModelName.TryGetValue(datasetModelName, out result))
{
result = GetDatasetByModelNameCore(datasetModelName, qualityCondition);
// can be null
datasetsByModelName.Add(datasetModelName, result);
}
return(result);
}
public IObjectDataset GetDatasetByInvolvedRowTableName(
string involvedRowTableName, QualityCondition qualityCondition)
{
Assert.ArgumentNotNullOrEmpty(involvedRowTableName, nameof(involvedRowTableName));
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
// the tablename in the involved row for stored error objects corresponds
// to the dataset name (model name), for errors written after the respective
// change in the domain model (allowing to use unqualified model names)
//
// error objects written before use the gdb table name
// -> search first in dataset names
// -> if not found: search in gdb dataset names
Dataset result = GetDatasetByModelName(involvedRowTableName, qualityCondition);
if (result != null)
{
// match found by model name
return(result as IObjectDataset);
}
// TODO handle changed "harvest qualified" / "unqualified" setting
// -> qualified involved dataset name -> unqualified model name --> already done, see below
// -> unqualified involved dataset name -> qualified model name --> TODO qualify by harvested schema owner/database (IF UNIQUE)
// the involved row name is qualified, maybe it was saved with an earlier version
// TODO store error object "version" -> allow adaptive rules?
return(GetDatasetByGdbTableName(involvedRowTableName, qualityCondition));
}
public static AllowedError FindAllowedErrorInSortedList(
[NotNull] List <AllowedError> allowedErrors,
[NotNull] QaError qaError,
[NotNull] QualityCondition qualityCondition,
[NotNull] ISpatialReference spatialReference,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver,
[NotNull] ICollection <esriGeometryType> storedGeometryTypes,
bool forPre10Geodatabase)
{
Assert.ArgumentNotNull(allowedErrors, nameof(allowedErrors));
Assert.ArgumentNotNull(qaError, nameof(qaError));
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
Assert.ArgumentNotNull(spatialReference, nameof(spatialReference));
Assert.ArgumentNotNull(storedGeometryTypes, nameof(storedGeometryTypes));
if (allowedErrors.Count <= 0)
{
return(null);
}
QaError asStoredError = GetForAllowedErrorComparison(
qaError, spatialReference, storedGeometryTypes, forPre10Geodatabase);
int index = FindAllowedErrorIndex(asStoredError,
qualityCondition,
allowedErrors,
datasetResolver);
return(index < 0
? null
: allowedErrors[index]);
}
public static string GetInvolvedObjectsString(
[NotNull] QualityCondition qualityCondition,
[NotNull] QaError qaError,
[NotNull] ICollection <ITest> tests,
int maxLength,
[NotNull] IQualityConditionObjectDatasetResolver datasetResolver)
{
IEnumerable <InvolvedRow> involvedRowsWithDatasetNames =
GetInvolvedRows(qaError,
qualityCondition,
datasetResolver);
if (tests.Count == 1)
{
return(RowParser.Format(involvedRowsWithDatasetNames, maxLength));
}
var testIndex = 0;
foreach (ITest test in tests)
{
if (test == qaError.Test)
{
return(RowParser.Format(test, testIndex, involvedRowsWithDatasetNames,
maxLength));
}
testIndex++;
}
throw new InvalidProgramException(
string.Format("Test {0} not found in QualityCondition {1}",
qaError.Test.GetType(), qualityCondition.Name));
}
private static IDictionary GetDatasetCategories(
[NotNull] IEnumerable <SpecificationDataset> specificationDatasets,
[NotNull] IComparer <DatasetCategoryItem> categoryComparer,
[NotNull] IComparer <Dataset> datasetComparer)
{
IDictionary result = new SortedDictionary <DatasetCategoryItem, object>(
categoryComparer);
foreach (SpecificationDataset specificationDataset in specificationDatasets)
{
QualityCondition condition = specificationDataset.QualityCondition;
if (condition == null)
{
continue;
}
foreach (Dataset dataset in condition.GetDatasetParameterValues())
{
var datasetCategoryItem = new DatasetCategoryItem(dataset.DatasetCategory);
if (result.Contains(datasetCategoryItem))
{
continue;
}
IDictionary datasetDict =
new SortedDictionary <Dataset, object>(datasetComparer);
result.Add(datasetCategoryItem, datasetDict);
}
}
return(result);
}
public void SetCondition(
[NotNull] QualityConditionVerification conditionVerification)
{
Assert.ArgumentNotNull(conditionVerification, nameof(conditionVerification));
_verification = conditionVerification;
QualityCondition displayableCondition = conditionVerification.DisplayableCondition;
_qualityConditionControl.QualityCondition = displayableCondition;
_qualityConditionTableViewControl.SetQualityCondition(displayableCondition);
_testDescriptorControl.TestDescriptor = displayableCondition.TestDescriptor;
_textBoxIssueCount.Text = _verification.ErrorCount.ToString("N0");
_textBoxIssueCount.BackColor = GetErrorBackColor(conditionVerification);
_textBoxIssueType.Text = _verification.AllowErrors
? "Warning"
: "Error";
// TODO: Handle StopOnError enumeration
_textBoxStopCondition.Text = _verification.StopCondition == null
? "None"
: string.Format("Stopped after error in {0}",
_verification.StopCondition.Name);
//else if (_verification.StopCondition == _verification.QualityCondition)
//{
// _textBoxStopCondition.Text = "Stopped for this and following tests";
//}
}
public void CanGroupQualityConditionsWithCompleteExclusion()
{
var catA = new DataQualityCategory("A");
var catA1 = new DataQualityCategory("A1");
var catA11 = new DataQualityCategory("A11");
catA.AddSubCategory(catA1);
catA1.AddSubCategory(catA11);
var test = new TestDescriptor("test", new ClassDescriptor(typeof(QaMinSegAngle)));
var qc1 = new QualityCondition("qc1", test)
{
Category = catA11
};
var qc2 = new QualityCondition("qc2", test)
{
Category = catA11
};
var qc3 = new QualityCondition("qc3", test)
{
Category = catA11
};
var issueGroups = new List <IssueGroup>
{
CreateIssueGroup(qc1, "ic1", 3),
CreateIssueGroup(qc2, "ic2", 4),
CreateIssueGroup(qc3, "ic3", 5),
CreateIssueGroup(qc3, "ic4", 6)
};
var reportDefinition = new HtmlReportDefinition(
"templatepath", "fileName",
new List <HtmlDataQualityCategoryOptions>
{
new HtmlDataQualityCategoryOptions(catA.Uuid, ignoreCategoryLevel: true),
new HtmlDataQualityCategoryOptions(catA1.Uuid, ignoreCategoryLevel: true),
new HtmlDataQualityCategoryOptions(catA11.Uuid, ignoreCategoryLevel: true),
});
List <HtmlReportIssueGroup> reportIssueGroups;
List <HtmlReportDataQualityCategory> reportCategories =
GroupByCategories(issueGroups, reportDefinition,
out reportIssueGroups);
Assert.AreEqual(4, reportIssueGroups.Count);
Assert.AreEqual(18, reportIssueGroups.Sum(ig => ig.IssueCount));
Assert.AreEqual(1, reportCategories.Count);
Assert.AreEqual(18, reportCategories.Sum(qc => qc.IssueCount));
List <HtmlReportDataQualityCategory> rootCategories =
reportCategories.Where(qc => qc.IsRoot)
.ToList();
Assert.AreEqual(1, rootCategories.Count);
Assert.AreEqual(18, rootCategories.Sum(qc => qc.IssueCountWithChildren));
}
