private QualityCondition GetDisplayableCondition()
{
// if there is a life reference to the correct version of the
// quality condition, directly return that reference
if (_qualityCondition != null)
{
if (_qualityCondition.Id == _qualityConditionId &&
_qualityCondition.Version == _qualityConditionVersion)
{
return(_qualityCondition);
}
if (string.IsNullOrEmpty(_qualityConditionName))
{
// for backwards compatiblity
// _qualityConditionName == null --> _qualityConditionId/ -Version invalid
// assume that quality condition is still valid
return(_qualityCondition);
}
}
// either the qualiy condition was deleted, or it was changed since the verification
var result = new QualityCondition(assignUuids: true);
if (string.IsNullOrEmpty(_qualityConditionName))
{
result.Name = "<unknown>";
result.Description =
"unknown, deleted quality condition without stored " +
"information in quality verification";
return(result);
}
result.Name = _qualityConditionName;
foreach (TestParameterValue testParameterValue
in TestParameterStringUtils.ParseTestParameterValues(
_qualityConditionParamValues))
{
result.AddParameterValue(testParameterValue);
}
result.TestDescriptor = TestDescriptor.CreateDisplayableTestDescriptor(
_testType, _constructorId);
string description = _qualityCondition != null &&
_qualityCondition.Id == _qualityConditionId
? "changed test without stored description information" +
" (Version " + _qualityConditionVersion + " )"
: "unknown, deleted or changed test without stored description information";
result.Description = description + Environment.NewLine +
result.TestDescriptor.Description;
result.AllowErrorsOverride = _allowErrors;
result.StopOnErrorOverride = _stopOnError;
return(result);
}
private void CopyProperties([NotNull] QualityCondition target)
{
Assert.ArgumentNotNull(target, nameof(target));
target._name = Name;
target._testDescriptor = TestDescriptor;
target._description = Description;
target._notes = Notes;
target._url = Url;
target._allowErrorsOverride = AllowErrorsOverride;
target._stopOnErrorOverride = StopOnErrorOverride;
target._reportIndividualErrorsOverride = ReportIndividualErrorsOverride;
target.CanGroupIssuesByDescription = CanGroupIssuesByDescription;
target._neverFilterTableRowsUsingRelatedGeometry =
NeverFilterTableRowsUsingRelatedGeometry;
target._neverStoreRelatedGeometryForTableRowIssues =
NeverStoreRelatedGeometryForTableRowIssues;
foreach (TestParameterValue testParameterValue in ParameterValues)
{
target.AddParameterValue(testParameterValue.Clone());
}
target._category = _category;
}
public QualityVerification(
int qualitySpecificationId,
string qualitySpecificationName,
string qualitySpecificationDescription,
string userDisplayName,
[NotNull] IEnumerable <QualityConditionVerification> conditionVerifications)
{
_specificationId = qualitySpecificationId;
_specificationName = qualitySpecificationName;
_specificationDescription = qualitySpecificationDescription;
_operator = userDisplayName;
var datasets = new HashSet <Dataset>();
foreach (QualityConditionVerification conditionVerification in conditionVerifications)
{
_conditionVerifications.Add(conditionVerification);
QualityCondition condition = conditionVerification.QualityCondition;
Assert.NotNull(condition);
foreach (Dataset dataset in condition.GetDatasetParameterValues())
{
datasets.Add(dataset);
}
}
foreach (Dataset dataset in datasets)
{
_verificationDatasets.Add(new QualityVerificationDataset(dataset));
}
}
public void DisableNoErrorElements([CanBeNull] IList <Dataset> uneditedDatasets)
{
if (uneditedDatasets == null || uneditedDatasets.Count == 0)
{
return;
}
foreach (QualitySpecificationElement element in Elements)
{
QualityCondition condition = element.QualityCondition;
var enable = false;
foreach (TestParameterValue testParameterValue in condition.ParameterValues)
{
if (!(testParameterValue is DatasetTestParameterValue))
{
continue;
}
Dataset ds = ((DatasetTestParameterValue)testParameterValue).DatasetValue;
if (ds != null && uneditedDatasets.Contains(ds))
{
continue;
}
enable = true;
break;
}
if (!enable)
{
element.Enabled = false;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="QualityConditionVerification"/> class.
/// </summary>
/// <param name="element">The specification element that was verified.</param>
public QualityConditionVerification([NotNull] QualitySpecificationElement element)
{
Assert.ArgumentNotNull(element, nameof(element));
QualityCondition qualityCondition = element.QualityCondition;
_qualityCondition = qualityCondition;
_qualityConditionId = qualityCondition.Id;
_qualityConditionVersion = qualityCondition.Version;
_qualityConditionName = qualityCondition.Name;
_qualityConditionParamValues =
qualityCondition.GetParameterValuesString(_maxLengthParamValues);
TestDescriptor testDescriptor = qualityCondition.TestDescriptor;
ClassDescriptor testClass = testDescriptor.TestClass;
if (testClass != null)
{
_testType = testClass.TypeName;
_constructorId = testDescriptor.TestConstructorId;
}
else
{
ClassDescriptor factoryDescriptor = testDescriptor.TestFactoryDescriptor;
Assert.NotNull(factoryDescriptor,
"both TestClass and TestFactory descriptors are null");
_testType = factoryDescriptor.TypeName;
_constructorId = -1;
}
_allowErrors = element.AllowErrors;
_stopOnError = element.StopOnError;
}
public bool RemoveElement([NotNull] QualityCondition qualityCondition)
{
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
QualitySpecificationElement element = GetElement(qualityCondition);
return(element != null && _elements.Remove(element));
}
public QualityCondition CreateCopy()
{
var copy = new QualityCondition(assignUuids: true);
CopyProperties(copy);
return(copy);
}
public QualitySpecificationElement AddElement(
[NotNull] QualityCondition qualityCondition,
bool?stopOnErrorOverride, bool?allowErrorsOverride, bool disabled)
{
// add to end of list
return(AddElement(qualityCondition,
stopOnErrorOverride, allowErrorsOverride, _elements.Count,
disabled));
}
/// <summary>
/// Initializes a new instance of the <see cref="QualitySpecificationElement"/> class.
/// </summary>
/// <param name="condition">The quality condition.</param>
/// <param name="stopOnErrorOverride">The stop on error override.</param>
/// <param name="allowErrorsOverride">The allow errors override.</param>
/// <param name="disabled">if set to <c>true</c> the element will be disabled.</param>
public QualitySpecificationElement([NotNull] QualityCondition condition,
bool?stopOnErrorOverride = null,
bool?allowErrorsOverride = null,
bool disabled = false)
{
Assert.ArgumentNotNull(condition, nameof(condition));
_qualityCondition = condition;
_stopOnErrorOverride = stopOnErrorOverride;
_allowErrorsOverride = allowErrorsOverride;
Enabled = !disabled;
}
public QualitySpecificationElement AddElement(
[NotNull] QualityCondition qualityCondition, bool?stopOnErrorOverride,
bool?allowErrorsOverride, int insertIndex, bool disabled = false)
{
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
var element = new QualitySpecificationElement(
qualityCondition, stopOnErrorOverride, allowErrorsOverride, disabled);
_elements.Insert(insertIndex, element);
return(element);
}
private int IndexOf([NotNull] QualityCondition condition)
{
for (var i = 0; i < _elements.Count; i++)
{
QualitySpecificationElement element = _elements[i];
if (element.QualityCondition.Equals(condition))
{
return(i);
}
}
return(-1);
}
internal QualityCondition Clone()
{
var clone = new QualityCondition(assignUuids: false)
{
Uuid = Uuid,
VersionUuid = VersionUuid,
Version = Version,
_cloneId = Id
};
CopyProperties(clone);
return(clone);
}
public bool Contains([NotNull] QualityCondition qualityCondition)
{
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
foreach (QualitySpecificationElement element in _elements)
{
if (element.QualityCondition.Equals(qualityCondition))
{
return(true);
}
}
return(false);
}
public QualitySpecificationElement GetElement(
[NotNull] QualityCondition qualityCondition)
{
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
foreach (QualitySpecificationElement element in _elements)
{
if (qualityCondition.Equals(element.QualityCondition))
{
return(element);
}
}
return(null);
}
protected static bool IsQualityConditionApplicable(
[NotNull] QualityCondition condition,
[NotNull] HashSet <Dataset> verifiedDatasets)
{
Assert.ArgumentNotNull(condition, nameof(condition));
Assert.ArgumentNotNull(verifiedDatasets, nameof(verifiedDatasets));
IList <TestParameterValue> deleted = condition.GetDeletedParameterValues();
if (deleted.Count > 0)
{
// there are deleted parameter values
return(false);
}
return(condition.IsApplicableFor(verifiedDatasets,
onlyIfNotUsedAsReferenceData: true));
}
public double LoadTime([NotNull] QualityVerification verification)
{
double result = 0;
QualityCondition condition = DisplayableCondition;
foreach (Dataset dataset in condition.GetDatasetParameterValues())
{
QualityVerificationDataset verificationDataset =
verification.GetVerificationDataset(dataset);
if (verificationDataset == null)
{
continue;
}
result += verificationDataset.LoadTime;
}
return(result);
}
public void UnlinkQualityCondition([NotNull] QualityCondition qualityCondition)
{
Assert.ArgumentNotNull(qualityCondition, nameof(qualityCondition));
foreach (
QualityConditionVerification conditionVerification in _conditionVerifications)
{
if (conditionVerification.QualityCondition != null)
{
if (Equals(conditionVerification.QualityCondition, qualityCondition))
{
conditionVerification.ClearQualityCondition();
}
}
if (conditionVerification.StopCondition != null)
{
if (Equals(conditionVerification.StopCondition, qualityCondition))
{
conditionVerification.StopCondition = null;
}
}
}
}
public void UpdateParameterValuesFrom([NotNull] QualityCondition updateCondition,
bool updateIsOriginal = false)
{
var updateValues = new Dictionary <string, List <TestParameterValue> >();
foreach (TestParameterValue updateParameterValue in updateCondition.ParameterValues)
{
List <TestParameterValue> values;
if (!updateValues.TryGetValue(updateParameterValue.TestParameterName, out values))
{
values = new List <TestParameterValue>();
updateValues.Add(updateParameterValue.TestParameterName, values);
}
values.Add(updateParameterValue);
}
var hasUpdates = false;
var toRemoves = new List <TestParameterValue>();
foreach (TestParameterValue parameterValue in ParameterValues)
{
List <TestParameterValue> updates;
if (!updateValues.TryGetValue(parameterValue.TestParameterName, out updates) ||
updates.Count == 0)
{
toRemoves.Add(parameterValue);
hasUpdates = true;
continue;
}
TestParameterValue update = updates[0];
updates.RemoveAt(0);
if (parameterValue.UpdateFrom(update))
{
hasUpdates = true;
}
}
foreach (TestParameterValue toRemove in toRemoves)
{
RemoveParameterValue(toRemove);
}
foreach (List <TestParameterValue> missingValues in updateValues.Values)
{
foreach (TestParameterValue missingValue in missingValues)
{
AddParameterValue(missingValue);
hasUpdates = true;
}
}
if (hasUpdates)
{
Updated = true;
}
if (updateIsOriginal)
{
Updated = false;
}
}
public QualitySpecification Union([NotNull] QualitySpecification other,
out int equal)
{
Assert.ArgumentNotNull(other, nameof(other));
var result = new QualitySpecification(Name + "*" + other.Name)
{
_isUnion = true
};
equal = 0;
var minOther = 0;
// index des minimalen other elements, das noch nicht geprueft wurde, ob es in die union gehoert
foreach (QualitySpecificationElement thisElement in _elements)
{
bool stopOnError = thisElement.StopOnError;
bool allowErrors = thisElement.AllowErrors;
bool enabled = thisElement.Enabled;
int otherIndex = other.IndexOf(thisElement.QualityCondition);
if (otherIndex >= 0)
{
QualitySpecificationElement otherElement;
for (int idxOther = minOther; idxOther < otherIndex; idxOther++)
{
otherElement = other._elements[idxOther];
QualityCondition otherCond = otherElement.QualityCondition;
if (IndexOf(otherCond) >= 0 || result.IndexOf(otherCond) >= 0)
{
continue;
}
result.AddElement(otherElement.QualityCondition,
otherElement.StopOnError,
otherElement.AllowErrors,
!otherElement.Enabled);
equal |= 2;
// == equal = equal | 2; Beispiel equal = 1 --> nachher equal = 1 | 2 = 3
}
minOther = otherIndex;
otherElement = other._elements[otherIndex];
if (stopOnError != otherElement.StopOnError)
{
equal |= stopOnError
? 1
: 2;
stopOnError = true;
}
if (allowErrors != otherElement.AllowErrors)
{
equal |= allowErrors
? 1
: 2;
allowErrors = true;
}
}
else
{
equal |= 1;
}
result.AddElement(thisElement.QualityCondition, stopOnError,
allowErrors, !enabled);
}
foreach (QualitySpecificationElement otherElement in other._elements)
{
int unionIndex = result.IndexOf(otherElement.QualityCondition);
if (unionIndex >= 0)
{
continue;
}
equal |= 2;
result.AddElement(otherElement.QualityCondition,
otherElement.StopOnError,
otherElement.AllowErrors,
!otherElement.Enabled);
}
return(result);
}
public QualityConditionVerification GetConditionVerification(
[NotNull] QualityCondition qualityCondition)
{
return(_conditionVerifications.FirstOrDefault(
verification => verification.QualityCondition == qualityCondition));
}
public void ClearQualityCondition()
{
_qualityCondition = null;
_displayableCondition = null;
}
public QualitySpecificationElement AddElement(
[NotNull] QualityCondition qualityCondition, int insertIndex)
{
return(AddElement(qualityCondition, null, null, insertIndex));
}
