public void NoChangeSpansBothDocuments()
{
DiffSet diffSet = DiffSet.GetDiffSet("this is a test", "this is a test");
Assert.IsFalse(diffSet.IsEmpty);
Assert.IsFalse(diffSet.ContainsChanges);
Assert.AreElementsEqual(new Diff[] { new Diff(DiffKind.NoChange, new Range(0, 14), new Range(0, 14)) }, diffSet.Diffs);
}
public void ComputedDiffIsEmpty()
{
DiffSet diffSet = DiffSet.GetDiffSet("", "");
Assert.IsTrue(diffSet.IsEmpty);
Assert.IsFalse(diffSet.ContainsChanges);
Assert.AreElementsEqual(new Diff[] { }, diffSet.Diffs);
}
public void IfRightDocumentIsEmptyChangeSpansLeftDocument()
{
DiffSet diffSet = DiffSet.GetDiffSet("abcde", "");
Assert.IsFalse(diffSet.IsEmpty);
Assert.IsTrue(diffSet.ContainsChanges);
Assert.AreElementsEqual(new Diff[] { new Diff(DiffKind.Change, new Range(0, 5), new Range(0, 0)) },
diffSet.Diffs);
}
public void SingleCharDelete([Column(false, true)] bool optimize)
{
DiffSet diffSet = DiffSet.GetDiffSet("1", "", optimize, true);
Assert.IsFalse(diffSet.IsEmpty);
Assert.IsTrue(diffSet.ContainsChanges);
Assert.AreElementsEqual(new Diff[] {
new Diff(DiffKind.Change, new Range(0, 1), new Range(0, 0))
}, diffSet.Diffs);
}
public void DeleteAtHeadAndInsertAtTail([Column(false, true)] bool optimize)
{
DiffSet diffSet = DiffSet.GetDiffSet("123", "234", optimize, true);
Assert.IsFalse(diffSet.IsEmpty);
Assert.IsTrue(diffSet.ContainsChanges);
Assert.AreElementsEqual(new Diff[] {
new Diff(DiffKind.Change, new Range(0, 1), new Range(0, 0)),
new Diff(DiffKind.NoChange, new Range(1, 2), new Range(0, 2)),
new Diff(DiffKind.Change, new Range(3, 0), new Range(2, 1))
}, diffSet.Diffs);
}
public void MultipleAdjacentChanges([Column(false, true)] bool optimize)
{
DiffSet diffSet = DiffSet.GetDiffSet("123abcdef", "abc456def", optimize, true);
Assert.IsFalse(diffSet.IsEmpty);
Assert.IsTrue(diffSet.ContainsChanges);
Assert.AreElementsEqual(new Diff[] {
new Diff(DiffKind.Change, new Range(0, 3), new Range(0, 0)),
new Diff(DiffKind.NoChange, new Range(3, 3), new Range(0, 3)),
new Diff(DiffKind.Change, new Range(6, 0), new Range(3, 3)),
new Diff(DiffKind.NoChange, new Range(6, 3), new Range(6, 3))
}, diffSet.Diffs);
}
public void ProblemSizeIsReducedButDiffOffsetsAreStillCorrect()
{
DiffSet diffSet = DiffSet.GetDiffSet("123abcZZdef45", "123uvZZxy45");
Assert.IsFalse(diffSet.IsEmpty);
Assert.IsTrue(diffSet.ContainsChanges);
Assert.AreElementsEqual(new Diff[] {
new Diff(DiffKind.NoChange, new Range(0, 3), new Range(0, 3)),
new Diff(DiffKind.Change, new Range(3, 3), new Range(3, 2)),
new Diff(DiffKind.NoChange, new Range(6, 2), new Range(5, 2)),
new Diff(DiffKind.Change, new Range(8, 3), new Range(7, 2)),
new Diff(DiffKind.NoChange, new Range(11, 2), new Range(9, 2))
}, diffSet.Diffs);
}
public void Simplify(string leftDocument, string rightDocument, int expectedNumberOfDiffs)
{
DiffSet originalDiffSet = DiffSet.GetDiffSet(leftDocument, rightDocument);
DiffSet simplifiedDiffSet = originalDiffSet.Simplify();
using (TestLog.BeginSection("Original DiffSet"))
originalDiffSet.WriteTo(TestLog.Default);
using (TestLog.BeginSection("Simplified DiffSet"))
simplifiedDiffSet.WriteTo(TestLog.Default);
VerifyDiffSetIsValid(simplifiedDiffSet);
Assert.LessThanOrEqualTo(simplifiedDiffSet.Diffs.Count, originalDiffSet.Diffs.Count);
Assert.AreEqual(expectedNumberOfDiffs, simplifiedDiffSet.Diffs.Count);
}
/// <summary>
/// Adds two raw labeled values formatted using <see cref="Formatter" /> and includes
/// formatting of their differences.
/// </summary>
/// <remarks>
/// <para>
/// The order in which this method is called determines the order in which the
/// values will appear relative to other labeled values.
/// </para>
/// </remarks>
/// <param name="leftLabel">The left label.</param>
/// <param name="leftValue">The left value.</param>
/// <param name="rightLabel">The right label.</param>
/// <param name="rightValue">The right value.</param>
/// <returns>The builder, to allow for fluent method chaining.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="leftLabel"/> or
/// <paramref name="rightLabel"/> is null.</exception>
public AssertionFailureBuilder AddRawLabeledValuesWithDiffs(
string leftLabel, object leftValue, string rightLabel, object rightValue)
{
if (leftLabel == null)
{
throw new ArgumentNullException("leftLabel");
}
if (rightLabel == null)
{
throw new ArgumentNullException("rightLabel");
}
if (ReferenceEquals(leftValue, rightValue))
{
AddRawLabeledValue(String.Format("{0} & {1}", leftLabel, rightLabel), leftValue);
AddLabeledValue("Remark", "Both values are the same instance.");
}
else
{
string formattedLeftValue = Formatter.Format(leftValue);
string formattedRightValue = Formatter.Format(rightValue);
if (formattedLeftValue == formattedRightValue)
{
AddLabeledValue(String.Format("{0} & {1}", leftLabel, rightLabel), formattedLeftValue);
AddLabeledValue("Remark", "Both values look the same when formatted but they are distinct instances.");
}
else
{
DiffSet diffSet = DiffSet.GetDiffSet(formattedLeftValue, formattedRightValue);
diffSet = diffSet.Simplify();
var highlightedLeftValueWriter = new StructuredTextWriter();
var highlightedRightValueWriter = new StructuredTextWriter();
diffSet.WriteTo(highlightedLeftValueWriter, DiffStyle.LeftOnly,
formattedLeftValue.Length <= AssertionFailure.MaxFormattedValueLength ? int.MaxValue : CompressedDiffContextLength);
diffSet.WriteTo(highlightedRightValueWriter, DiffStyle.RightOnly,
formattedRightValue.Length <= AssertionFailure.MaxFormattedValueLength ? int.MaxValue : CompressedDiffContextLength);
AddLabeledValue(leftLabel, highlightedLeftValueWriter.ToStructuredText());
AddLabeledValue(rightLabel, highlightedRightValueWriter.ToStructuredText());
}
}
return(this);
}
public void ShowsLabeledValuesWithDiffs_Difference()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("description");
builder.AddRawLabeledValuesWithDiffs("Left", "acde", "Right", "bcef");
DiffSet diffSet = DiffSet.GetDiffSet("\"acde\"", "\"bcef\"").Simplify();
StructuredTextWriter expectedValueWriter = new StructuredTextWriter();
diffSet.WriteTo(expectedValueWriter, DiffStyle.LeftOnly);
StructuredTextWriter actualValueWriter = new StructuredTextWriter();
diffSet.WriteTo(actualValueWriter, DiffStyle.RightOnly);
Assert.AreElementsEqual(new[]
{
new AssertionFailure.LabeledValue("Left", expectedValueWriter.ToStructuredText()),
new AssertionFailure.LabeledValue("Right", actualValueWriter.ToStructuredText())
}, builder.ToAssertionFailure().LabeledValues);
}
internal static void Check(string a, string b)
{
TestLog.WriteLine("A: " + a);
TestLog.WriteLine("B: " + b);
// Standard diff.
DiffSet diffSet = DiffSet.GetDiffSet(a, b);
TestLog.Write("Diff: ");
TestLog.WriteLine(diffSet);
VerifyDiffSetIsValid(diffSet);
// Also check simplified form.
DiffSet simplifiedDiffSet = diffSet.Simplify();
TestLog.Write("Simplified Diff: ");
TestLog.WriteLine(simplifiedDiffSet);
VerifyDiffSetIsValid(simplifiedDiffSet);
Assert.LessThanOrEqualTo(simplifiedDiffSet.Diffs.Count, diffSet.Diffs.Count);
}
private static long RunWorstCaseDiff(int problemSize, bool bounded)
{
StringBuilder left = new StringBuilder();
for (int i = 0; i < problemSize; i++)
{
left.Append((char)i);
}
StringBuilder right = new StringBuilder();
for (int i = problemSize; i < problemSize * 2; i++)
{
right.Append((char)i);
}
Stopwatch timer = Stopwatch.StartNew();
DiffSet diffSet = DiffSet.GetDiffSet(left.ToString(), right.ToString(), false, bounded);
Assert.IsFalse(diffSet.IsEmpty);
Assert.IsTrue(diffSet.ContainsChanges);
Assert.AreElementsEqual(new[] { new Diff(DiffKind.Change, new Range(0, problemSize), new Range(0, problemSize)) }, diffSet.Diffs);
return(timer.ElapsedMilliseconds);
}
public void GetDiffSetThrowsWhenRightDocumentIsNull()
{
DiffSet.GetDiffSet("", null);
}
public void GetDiffSetThrowsWhenLeftDocumentIsNull()
{
DiffSet.GetDiffSet(null, "");
}
