public void SlideEditRightRecursive()
{
// Slide edit right recursive.
var diffs = new List <Diff>
{
Diff.Equal("x"),
Diff.Delete("ca"),
Diff.Equal("c"),
Diff.Delete("b"),
Diff.Equal("a")
}.CleanupMerge().ToList();
Assert.Equal(new List <Diff> {
Diff.Equal("xca"), Diff.Delete("cba")
}, diffs);
}
public void Text2_ReturnsText2()
{
// Compute the source and destination texts.
var diffs = new List <Diff>
{
Diff.Equal("jump"),
Diff.Delete("s"),
Diff.Insert("ed"),
Diff.Equal(" over "),
Diff.Delete("the"),
Diff.Insert("a"),
Diff.Equal(" lazy")
};
Assert.Equal("jumped over a lazy", diffs.Text2());
}
public void SimpleElimination()
{
var diffs = new List <Diff>
{
Diff.Delete("a"),
Diff.Equal("b"),
Diff.Delete("c")
};
diffs.CleanupSemantic();
CollectionAssert.AreEqual(new List <Diff>
{
Diff.Delete("abc"),
Diff.Insert("b")
}, diffs);
}
public void ReverseOverlapElimination()
{
var diffs = new List <Diff>
{
Diff.Delete("xxxabc"),
Diff.Insert("defxxx")
};
diffs.CleanupSemantic();
CollectionAssert.AreEqual(new List <Diff>
{
Diff.Insert("def"),
Diff.Equal("xxx"),
Diff.Delete("abc")
}, diffs);
}
public void HittingTheStart()
{
var diffs = new List <Diff>
{
Diff.Equal("a"),
Diff.Delete("a"),
Diff.Equal("ax")
};
diffs.CleanupSemanticLossless();
CollectionAssert.AreEqual(new List <Diff>
{
Diff.Delete("a"),
Diff.Equal("aax")
}, diffs);
}
public void ThreeEditElimination()
{
var diffs = new List <Diff>
{
Diff.Insert("12"),
Diff.Equal("x"),
Diff.Delete("cd"),
Diff.Insert("34")
}.CleanupEfficiency();
Assert.Equal(new List <Diff>
{
Diff.Delete("xcd"),
Diff.Insert("12x34")
}, diffs);
}
public void WordBoundaries()
{
var diffs = new List <Diff>
{
Diff.Equal("The c"),
Diff.Delete("ow and the c"),
Diff.Equal("at.")
}.CleanupSemantic();
Assert.Equal(new List <Diff>
{
Diff.Equal("The "),
Diff.Delete("cow and the "),
Diff.Equal("cat.")
}, diffs);
}
public void FourEditElimination()
{
var diffs = new List <Diff>
{
Diff.Delete("ab"),
Diff.Insert("12"),
Diff.Equal("xyz"),
Diff.Delete("cd"),
Diff.Insert("34")
}.CleanupEfficiency();
Assert.Equal(new List <Diff>
{
Diff.Delete("abxyzcd"),
Diff.Insert("12xyz34")
}, diffs);
}
public void SlideEditLeftRecursive()
{
// Slide edit left recursive.
var diffs = new List <Diff>
{
Diff.Equal("a"),
Diff.Delete("b"),
Diff.Equal("c"),
Diff.Delete("ac"),
Diff.Equal("x")
};
diffs.CleanupMerge();
CollectionAssert.AreEqual(new List <Diff> {
Diff.Delete("abc"), Diff.Equal("acx")
}, diffs);
}
public void InterweavedInsertDeletesAreMerged()
{
// Merge interweave.
var diffs = new List <Diff>
{
Diff.Delete("a"),
Diff.Insert("b"),
Diff.Delete("c"),
Diff.Insert("d"),
Diff.Equal("e"),
Diff.Equal("f")
}.CleanupMerge().ToList();
Assert.Equal(new List <Diff> {
Diff.Delete("ac"), Diff.Insert("bd"), Diff.Equal("ef")
}, diffs);
}
public void ToString_ReturnsExpectedString()
{
// Patch Object.
var p = new Patch(20, 18, 21, 17, new[]
{
Diff.Equal("jump"),
Diff.Delete("s"),
Diff.Insert("ed"),
Diff.Equal(" over "),
Diff.Delete("the"),
Diff.Insert("a"),
Diff.Equal("\nlaz")
}.ToImmutableList());
var strp = "@@ -21,18 +22,17 @@\n jump\n-s\n+ed\n over \n-the\n+a\n %0alaz\n";
Assert.Equal(strp, p.ToString());
}
public void PrefixSuffixDetectionWithEqualities()
{
// Prefix and suffix detection.
var diffs = new List <Diff>
{
Diff.Equal("x"),
Diff.Delete("a"),
Diff.Insert("abc"),
Diff.Delete("dc"),
Diff.Equal("y")
}.CleanupMerge().ToList();
Assert.Equal(
new List <Diff> {
Diff.Equal("xa"), Diff.Delete("d"), Diff.Insert("b"), Diff.Equal("cy")
}, diffs);
}
public void BackpassElimination()
{
var diffs = new List <Diff>
{
Diff.Delete("ab"),
Diff.Equal("cd"),
Diff.Delete("e"),
Diff.Equal("f"),
Diff.Insert("g")
}.CleanupSemantic();
Assert.Equal(new List <Diff>
{
Diff.Delete("abcdef"),
Diff.Insert("cdfg")
}, diffs);
}
public void ThreeDiffs_WhenCleaned_Remains()
{
// Blank lines.
var diffs = new List <Diff>
{
Diff.Equal("AAA"),
Diff.Insert("BBB"),
Diff.Delete("CCC"),
}.CleanupSemanticLossless().ToList();
Assert.Equal(new List <Diff>
{
Diff.Equal("AAA"),
Diff.Insert("BBB"),
Diff.Delete("CCC"),
}, diffs);
}
public void ToDelta_GeneratesExpectedOutput()
{
var diffs = new List <Diff>
{
Diff.Equal("jump"),
Diff.Delete("s"),
Diff.Insert("ed"),
Diff.Equal(" over "),
Diff.Delete("the"),
Diff.Insert("a"),
Diff.Equal(" lazy"),
Diff.Insert("old dog")
};
var delta = diffs.ToDelta();
Assert.AreEqual("=4\t-1\t+ed\t=6\t-3\t+a\t=5\t+old dog", delta);
}
public void ToDelta_InputTooShort_Throws()
{
var diffs = new List <Diff>
{
Diff.Equal("jump"),
Diff.Delete("s"),
Diff.Insert("ed"),
Diff.Equal(" over "),
Diff.Delete("the"),
Diff.Insert("a"),
Diff.Equal(" lazy"),
Diff.Insert("old dog")
};
var delta = diffs.ToDelta();
var text1 = diffs.Text1().Substring(1);
Assert.Throws <ArgumentException>(() => DiffList.FromDelta(text1, delta).ToList());
}
public void FromDelta_GeneratesExpectedDiffs()
{
var diffs = new List <Diff>
{
Diff.Equal("jump"),
Diff.Delete("s"),
Diff.Insert("ed"),
Diff.Equal(" over "),
Diff.Delete("the"),
Diff.Insert("a"),
Diff.Equal(" lazy"),
Diff.Insert("old dog")
};
var delta = diffs.ToDelta();
var result = DiffList.FromDelta(diffs.Text1(), delta);
CollectionAssert.AreEqual(diffs, result.ToList());
}
public void NoElimination2()
{
var diffs = new List <Diff>
{
Diff.Delete("abc"),
Diff.Insert("ABC"),
Diff.Equal("1234"),
Diff.Delete("wxyz")
}.CleanupSemantic();
Assert.Equal(new List <Diff>
{
Diff.Delete("abc"),
Diff.Insert("ABC"),
Diff.Equal("1234"),
Diff.Delete("wxyz")
}, diffs);
}
public void NoEliminiation1()
{
var diffs = new List <Diff>
{
Diff.Delete("ab"),
Diff.Insert("cd"),
Diff.Equal("12"),
Diff.Delete("e")
}.CleanupSemantic();
Assert.Equal(new List <Diff>
{
Diff.Delete("ab"),
Diff.Insert("cd"),
Diff.Equal("12"),
Diff.Delete("e")
}, diffs);
}
public void BackpassElimination()
{
var diffs = new List <Diff>
{
Diff.Delete("ab"),
Diff.Insert("12"),
Diff.Equal("xy"),
Diff.Insert("34"),
Diff.Equal("z"),
Diff.Delete("cd"),
Diff.Insert("56")
}.CleanupEfficiency();
Assert.Equal(new List <Diff>
{
Diff.Delete("abxyzcd"),
Diff.Insert("12xy34z56")
}, diffs);
}
public void HighCostElimination()
{
short highDiffEditCost = 5;
var diffs = new List <Diff>
{
Diff.Delete("ab"),
Diff.Insert("12"),
Diff.Equal("wxyz"),
Diff.Delete("cd"),
Diff.Insert("34")
}.CleanupEfficiency(highDiffEditCost);
Assert.Equal(new List <Diff>
{
Diff.Delete("abwxyzcd"),
Diff.Insert("12wxyz34")
}, diffs);
}
public void DiffBisectTest_NoTimeout()
{
// Normal.
var a = "cat";
var b = "map";
// Since the resulting diff hasn't been normalized, it would be ok if
// the insertion and deletion pairs are swapped.
// If the order changes, tweak this test as required.
var diffs = new List <Diff>
{
Diff.Delete("c"),
Diff.Insert("m"),
Diff.Equal("a"),
Diff.Delete("t"),
Diff.Insert("p")
};
Assert.Equal(diffs, DiffAlgorithm.MyersDiffBisect(a, b, false, new CancellationToken()));
}
public void FourEditElimination()
{
var diffs = new List <Diff>
{
Diff.Delete("ab"),
Diff.Insert("12"),
Diff.Equal("xyz"),
Diff.Delete("cd"),
Diff.Insert("34")
}.CleanupMerge().ToList();
Assert.Equal(new List <Diff>
{
Diff.Delete("ab"),
Diff.Insert("12"),
Diff.Equal("xyz"),
Diff.Delete("cd"),
Diff.Insert("34")
}, diffs);
}
public void NoElimination()
{
var diffs = new List <Diff>
{
Diff.Delete("ab"),
Diff.Insert("12"),
Diff.Equal("wxyz"),
Diff.Delete("cd"),
Diff.Insert("34")
};
diffs.CleanupEfficiency();
CollectionAssert.AreEqual(new List <Diff>
{
Diff.Delete("ab"),
Diff.Insert("12"),
Diff.Equal("wxyz"),
Diff.Delete("cd"),
Diff.Insert("34")
}, diffs);
}
public void MultipleEliminations()
{
var diffs = new List <Diff>
{
Diff.Insert("1"),
Diff.Equal("A"),
Diff.Delete("B"),
Diff.Insert("2"),
Diff.Equal("_"),
Diff.Insert("1"),
Diff.Equal("A"),
Diff.Delete("B"),
Diff.Insert("2")
}.CleanupSemantic();
Assert.Equal(new List <Diff>
{
Diff.Delete("AB_AB"),
Diff.Insert("1A2_1A2")
}, diffs);
}
public void TwoOverlapEliminations()
{
var diffs = new List <Diff>
{
Diff.Delete("abcd1212"),
Diff.Insert("1212efghi"),
Diff.Equal("----"),
Diff.Delete("A3"),
Diff.Insert("3BC")
}.CleanupSemantic();
Assert.Equal(new List <Diff>
{
Diff.Delete("abcd"),
Diff.Equal("1212"),
Diff.Insert("efghi"),
Diff.Equal("----"),
Diff.Delete("A"),
Diff.Equal("3"),
Diff.Insert("BC")
}, diffs);
}
public void Delta_SpecialCharacters_Works()
{
var zero = (char)0;
var one = (char)1;
var two = (char)2;
var diffs2 = new List <Diff>
{
Diff.Equal("\u0680 " + zero + " \t %"),
Diff.Delete("\u0681 " + one + " \n ^"),
Diff.Insert("\u0682 " + two + " \\ |")
};
var text1 = diffs2.Text1();
Assert.AreEqual("\u0680 " + zero + " \t %\u0681 " + one + " \n ^", text1);
var delta = diffs2.ToDelta();
// Lowercase, due to UrlEncode uses lower.
Assert.AreEqual("=7\t-7\t+%da%82 %02 %5c %7c", delta, "diff_toDelta: Unicode.");
CollectionAssert.AreEqual(diffs2, DiffList.FromDelta(text1, delta).ToList(), "diff_fromDelta: Unicode.");
}
