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;
}
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";
//}
}
private static void AssignExecutionTime(
[NotNull] ITest test,
[NotNull] QualityConditionVerification conditionVerification,
[NotNull] VerificationTimeStats verificationTimes)
{
double milliseconds;
if (verificationTimes.TryGetTestTime(test, out milliseconds))
{
conditionVerification.ExecuteTime = milliseconds / 1000.0;
return;
}
var containerTest = test as ContainerTest;
if (containerTest == null)
{
return;
}
double rowMilliseconds;
double tileCompletionMilliseconds;
if (verificationTimes.TryGetContainerTestTimes(containerTest,
out rowMilliseconds,
out tileCompletionMilliseconds))
{
conditionVerification.RowExecuteTime = rowMilliseconds / 1000.0;
conditionVerification.TileExecuteTime = tileCompletionMilliseconds / 1000.0;
}
}
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 bool IncludeConditionVerification(
[NotNull] QualityConditionVerification conditionVerification)
{
if (conditionVerification.ErrorCount == 0 &&
_toolStripButtonNoIssues.Checked)
{
return(true);
}
if (conditionVerification.ErrorCount > 0 &&
conditionVerification.AllowErrors &&
_toolStripButtonWarnings.Checked)
{
return(true);
}
if (conditionVerification.ErrorCount > 0 &&
!conditionVerification.AllowErrors &&
_toolStripButtonErrors.Checked)
{
return(true);
}
return(false);
}
private static QualityConditionVerification FindQualityConditionVerification(
QualityVerification toOverallVerification, int conditionId)
{
QualityConditionVerification conditionVerification =
toOverallVerification.ConditionVerifications.First(
c => Assert.NotNull(c.QualityCondition).Id ==
conditionId);
return(conditionVerification);
}
private bool ProcessQaError([NotNull] QaError qaError)
{
Assert.ArgumentNotNull(qaError, nameof(qaError));
if (_msg.IsVerboseDebugEnabled)
{
_msg.DebugFormat("Issue found: {0}", qaError);
}
// TODO: Consider checking basic relevance (inside test perimeter?) here
var eventArgs = new QaErrorEventArgs(qaError);
QaError?.Invoke(this, eventArgs);
if (eventArgs.Cancel)
{
return(false);
}
ITest test = qaError.Test;
QualityConditionVerification conditionVerification =
GetQualityConditionVerification(test);
QualityCondition qualityCondition = conditionVerification.QualityCondition;
Assert.NotNull(qualityCondition, "no quality condition for verification");
StopInfo stopInfo = null;
if (conditionVerification.StopOnError)
{
stopInfo = new StopInfo(qualityCondition, qaError.Description);
foreach (InvolvedRow involvedRow in qaError.InvolvedRows)
{
RowsWithStopConditions.Add(involvedRow.TableName,
involvedRow.OID, stopInfo);
}
}
if (!conditionVerification.AllowErrors)
{
conditionVerification.Fulfilled = false;
if (stopInfo != null)
{
// it's a stop condition, and it is a 'hard' condition, and the error is
// relevant --> consider the stop situation as sufficiently reported
// (no reporting in case of stopped tests required)
stopInfo.Reported = true;
}
}
return(true);
}
private static void AddVerification([NotNull] QualityVerificationMsg verificationMsg,
[CanBeNull] QualityVerification toOverallVerification)
{
if (toOverallVerification == null)
{
return;
}
if (verificationMsg.Cancelled)
{
toOverallVerification.Cancelled = true;
}
foreach (var conditionVerificationMsg in verificationMsg.ConditionVerifications)
{
int conditionId = conditionVerificationMsg.QualityConditionId;
QualityConditionVerification conditionVerification =
FindQualityConditionVerification(toOverallVerification, conditionId);
conditionVerification.ErrorCount += conditionVerificationMsg.ErrorCount;
conditionVerification.ExecuteTime += conditionVerificationMsg.ExecuteTime;
conditionVerification.RowExecuteTime += conditionVerificationMsg.RowExecuteTime;
conditionVerification.TileExecuteTime += conditionVerificationMsg.TileExecuteTime;
if (!conditionVerificationMsg.Fulfilled)
{
conditionVerification.Fulfilled = false;
}
if (conditionVerificationMsg.StopConditionId >= 0)
{
conditionVerification.StopCondition =
FindQualityConditionVerification(toOverallVerification,
conditionVerificationMsg.StopConditionId)
.QualityCondition;
}
}
foreach (var datasetMsg in verificationMsg.VerificationDatasets)
{
QualityVerificationDataset qualityVerificationDataset =
toOverallVerification.VerificationDatasets.First(
d => d.Dataset.Id == datasetMsg.DatasetId);
qualityVerificationDataset.LoadTime += datasetMsg.LoadTime;
}
toOverallVerification.ContextName = verificationMsg.ContextName;
toOverallVerification.ContextType = verificationMsg.ContextType;
toOverallVerification.ProcessorTimeSeconds += verificationMsg.ProcessorTimeSeconds;
toOverallVerification.RowsWithStopConditions += verificationMsg.RowsWithStopConditions;
toOverallVerification.Operator = verificationMsg.UserName;
}
public TestVerification([NotNull] QualityConditionVerification verification,
int testIndex)
{
Assert.ArgumentNotNull(verification, nameof(verification));
Assert.ArgumentCondition(verification.QualityCondition != null,
"quality condition is undefined");
QualityConditionVerification = verification;
QualityCondition = verification.QualityCondition;
TestIndex = testIndex;
}
private static VerifiedDatasetItem CreateVerifiedDatasetItem(
[NotNull] QualityVerification qualityVerification,
[NotNull] Dataset dataset,
[NotNull] QualityConditionVerification conditionVerification)
{
QualityVerificationDataset verifiedDataset =
qualityVerification.GetVerificationDataset(dataset);
return(new VerifiedDatasetItem(conditionVerification, dataset,
verifiedDataset == null
? 0
: verifiedDataset.LoadTime));
}
private static void LogConditionVerification(
[NotNull] QualityConditionVerification conditionVerification)
{
_msg.DebugFormat("{0}: {1:N0} {2} ({3:N2} ms)",
conditionVerification.QualityCondition == null
? "<null>"
: conditionVerification.QualityCondition.Name,
conditionVerification.ErrorCount,
conditionVerification.AllowErrors
? "warning(s)"
: "error(s)",
conditionVerification.TotalExecuteTime * 1000);
}
private static Color GetErrorBackColor(
[NotNull] QualityConditionVerification conditionVerification)
{
// TODO remove redundancy with QAVerificationForm (same colors used there)
if (conditionVerification.ErrorCount == 0)
{
return(Color.LightGreen);
}
return(conditionVerification.AllowErrors
? Color.Yellow
: Color.FromArgb(255, 100, 100));
}
private void SetQualityConditionVerification([CanBeNull] TreeNode node)
{
QualityConditionVerification qualityConditionVerification =
GetQualityConditionVerification(node);
if (qualityConditionVerification == null)
{
_qualityConditionVerificationControl.Clear();
_groupBoxCondition.Enabled = false;
}
else
{
SetQualityConditionVerification(qualityConditionVerification);
_groupBoxCondition.Enabled = true;
}
}
private void SetQualityConditionVerification(
[NotNull] QualityConditionVerification conditionVerification)
{
Assert.ArgumentNotNull(conditionVerification, nameof(conditionVerification));
_domainTransactionManager.UseTransaction(
delegate
{
QualityCondition condition = conditionVerification.DisplayableCondition;
if (condition.IsPersistent)
{
_domainTransactionManager.Reattach(condition);
}
_qualityConditionVerificationControl.SetCondition(conditionVerification);
});
}
private List <QualityConditionVerification> GetQualityConditionVerifications(
[NotNull] QualityVerificationMsg msg)
{
List <QualityConditionVerification> conditionVerifications =
new List <QualityConditionVerification>();
Dictionary <int, QualityCondition> conditionsById =
new Dictionary <int, QualityCondition>();
foreach (var conditionVerificationMsg in msg.ConditionVerifications)
{
int qualityConditionId = conditionVerificationMsg.QualityConditionId;
QualityCondition qualityCondition = GetQualityCondition(
qualityConditionId, conditionsById);
Assert.NotNull(qualityCondition, $"Condition {qualityConditionId} not found");
// TODO: AllowError/StopOnError
QualitySpecificationElement element =
new QualitySpecificationElement(qualityCondition);
var conditionVerification = new QualityConditionVerification(element);
conditionVerification.Fulfilled = conditionVerificationMsg.Fulfilled;
conditionVerification.ErrorCount = conditionVerificationMsg.ErrorCount;
conditionVerification.ExecuteTime = conditionVerificationMsg.ExecuteTime;
conditionVerification.RowExecuteTime = conditionVerificationMsg.RowExecuteTime;
conditionVerification.TileExecuteTime = conditionVerificationMsg.TileExecuteTime;
if (conditionVerificationMsg.StopConditionId >= 0)
{
conditionVerification.StopCondition = GetQualityCondition(
conditionVerificationMsg.StopConditionId, conditionsById);
}
conditionVerifications.Add(conditionVerification);
}
return(conditionVerifications);
}
private static TreeNode AddNode([NotNull] TreeNodeCollection nodes,
[NotNull] SpecificationDataset specificationDataset)
{
Assert.NotNull(specificationDataset.QualityCondition);
TreeNode node = nodes.Add(specificationDataset.QualityCondition.Name);
QualitySpecificationElement element =
specificationDataset.QualitySpecificationElement;
if (element != null)
{
node.Tag = element;
node.Checked = element.Enabled;
if (element.AllowErrors)
{
node.ImageKey = _allowErrors;
node.SelectedImageKey = _allowErrors;
}
else if (element.StopOnError == false)
{
node.ImageKey = _continueOnErrors;
node.SelectedImageKey = _continueOnErrors;
}
else
{
node.ImageKey = _stopOnErrors;
node.SelectedImageKey = _stopOnErrors;
}
}
QualityConditionVerification verification =
specificationDataset.QualityConditionVerification;
if (verification != null)
{
ConfigureVerificationNode(node, verification);
}
return(node);
}
private bool TryReportStopInfo(
[NotNull] StopInfo stopInfo,
[NotNull] IRow row,
[NotNull] QualityConditionVerification qualityConditionVerification)
{
Assert.ArgumentNotNull(stopInfo, nameof(stopInfo));
Assert.ArgumentNotNull(row, nameof(row));
Assert.ArgumentNotNull(qualityConditionVerification,
nameof(qualityConditionVerification));
qualityConditionVerification.StopCondition = stopInfo.QualityCondition;
QualityCondition stoppedCondition = qualityConditionVerification.QualityCondition;
Assert.NotNull(stoppedCondition, "stoppedCondition");
// TODO gather all stopped conditions for the row, report at end
// https://issuetracker02.eggits.net/browse/COM-248
IGeometry errorGeom = TestUtils.GetShapeCopy(row);
IList <ITest> stoppedTests = _testsByCondition[stoppedCondition];
string description =
TestExecutionUtils.GetStopInfoErrorDescription(stopInfo);
foreach (ITest stoppedTest in stoppedTests)
{
// TODO add issue code
var error = new QaError(stoppedTest, description,
new[] { new InvolvedRow(row) },
errorGeom, null, null);
bool reported = ProcessQaError(error);
if (reported)
{
return(true);
}
}
return(false);
}
private static void ConfigureVerificationNode(
[NotNull] TreeNode node,
[NotNull] QualityConditionVerification verification)
{
node.Tag = verification;
if (verification.ErrorCount == 0)
{
node.ImageKey = _imageKeyNoIssues;
node.SelectedImageKey = _imageKeyNoIssues;
}
else if (verification.AllowErrors)
{
node.ImageKey = _imageKeyWarning;
node.SelectedImageKey = _imageKeyWarning;
}
else
{
node.ImageKey = _imageKeyError;
node.SelectedImageKey = _imageKeyError;
}
}
public SpecificationDataset(
[NotNull] QualityConditionVerification qualityConditionVerification)
{
QualityConditionVerification = qualityConditionVerification;
}
