public void AddCheckOnlyDifference(PositionalDifference checkDifference)
{
if (MissingBaselineFile || MissingSecondaryFile)
{
throw new System.Exception("Cant have differences if a file is missing.");
}
_checkOnlyDifferences.Add(checkDifference);
}
public PositionalComparisonDifference(PositionalDifference baselineDifference, PositionalDifference checkDifference, PositionalComparisonDisposition disposition)
{
BaselineDifference = baselineDifference;
CheckDifference = checkDifference;
Disposition = disposition;
}
public void AddPositionallyMatchedDifference(PositionalDifference baselineDifference, PositionalDifference checkDifference, PositionalComparisonDisposition disposition)
{
_positionallyMatchedDifferences.Add(new PositionalComparisonDifference(baselineDifference, checkDifference, disposition));
}
public FileComparisonDifference Compare()
{
int baselineDiffIndex = 0;
int checkDiffIndex = 0;
FileComparisonDifference fileResult = new FileComparisonDifference(BaselineComparisonDifferences.File);
while (baselineDiffIndex < BaselineComparisonDifferences.Differences.Count && checkDiffIndex < CheckComparisonDifferences.Differences.Count)
{
PositionalDifference baselineDiff = BaselineComparisonDifferences.Differences[baselineDiffIndex];
PositionalDifference checkDiff = CheckComparisonDifferences.Differences[checkDiffIndex];
if (Math.Abs(baselineDiff.BaselineStartPosition - checkDiff.BaselineStartPosition) > baselineDiff.LocationLeeway)
{
// The differences are too far apart in absolute baseline position, it's a non-match. Consume the first one.
// Once one of these occurs, the overall match has failed, and the rest will probably be bad too.
if (baselineDiff.BaselineStartPosition < checkDiff.BaselineStartPosition)
{
fileResult.AddBaselineOnlyDifference(baselineDiff);
++baselineDiffIndex;
}
else
{
fileResult.AddCheckOnlyDifference(checkDiff);
++checkDiffIndex;
}
}
else
{
// the differences are close enough to compare to each other.
if (baselineDiff.Classification != checkDiff.Classification)
{
// The classifications are different, it's a non-match
fileResult.AddPositionallyMatchedDifference(baselineDiff, checkDiff, PositionalComparisonDisposition.DatatypeMismatch);
}
else if (Math.Abs(baselineDiff.SecondaryData.Length - checkDiff.SecondaryData.Length) > baselineDiff.LocationLeeway)
{
// The check data length is more than the allowed difference in length.
fileResult.AddPositionallyMatchedDifference(baselineDiff, checkDiff, PositionalComparisonDisposition.LengthMismatch);
}
else
{
fileResult.AddPositionallyMatchedDifference(baselineDiff, checkDiff, PositionalComparisonDisposition.Match);
}
// The baseline & check differences are positionally similar in the above cases, both get consumed.
++baselineDiffIndex;
++checkDiffIndex;
}
}
// One of the comparisons may have additional unhandled differences, can't possibly be both.
// So at most one of these loops can actually iterate.
while (baselineDiffIndex < BaselineComparisonDifferences.Differences.Count)
{
PositionalDifference baselineDiff = BaselineComparisonDifferences.Differences[baselineDiffIndex];
fileResult.AddBaselineOnlyDifference(baselineDiff);
++baselineDiffIndex;
}
while (checkDiffIndex < CheckComparisonDifferences.Differences.Count)
{
PositionalDifference checkDiff = CheckComparisonDifferences.Differences[checkDiffIndex];
fileResult.AddCheckOnlyDifference(checkDiff);
++checkDiffIndex;
}
// verify the results are sane - that all differences got classified.
int classifiedDiffCount = fileResult.BaselineOnlyDifferences.Count + fileResult.SecondaryOnlyDifferences.Count
+ 2 * fileResult.PositionallyMatchedDifferences.Count; // these are counted twice because they consume both a baseline & secondary diff
int actualDiffCount = BaselineComparisonDifferences.Differences.Count + CheckComparisonDifferences.Differences.Count;
if (classifiedDiffCount != actualDiffCount)
{
fileResult.HasDifferenceResolutionError = true;
}
return(fileResult);
}
