public void Will_throw_is_NewText_is_null()
{
var differ = new Mock <IDiffer>();
var builder = new SideBySideDiffBuilder(differ.Object);
var ex = Record.Exception(() => builder.BuildDiffModel("asa", null));
Assert.IsType <ArgumentNullException>(ex);
var an = (ArgumentNullException)ex;
Assert.Equal("newText", an.ParamName);
}
public List <string> GetDiffer(string OldText, string NewText)
{
List <string> Diff = new List <string>();
var inlineBuilder = new SideBySideDiffBuilder(new Differ());
var diffmodel = inlineBuilder.BuildDiffModel(OldText, NewText);
Diff.Add(Differ(diffmodel.OldText));
Diff.Add(Differ(diffmodel.NewText));
return(Diff);
}
private void Form1_Load(object sender, System.EventArgs e)
{
var d = new Differ();
var inlineBuilder = new SideBySideDiffBuilder(d);
var diffmodel = inlineBuilder.BuildDiffModel(OldText, NewText);
webBrowser1.DocumentText = GetHtml2Render(diffmodel.OldText);
webBrowser2.DocumentText = GetHtml2Render(diffmodel.NewText);
webBrowser1.Refresh();
webBrowser2.Refresh();
}
public void Will_not_ignore_word_white_space()
{
string oldText = "My name is matt";
string newText = "My name is matt";
var sideBySideDiffBuilder = new SideBySideDiffBuilder();
var sideBySideDiffModel = sideBySideDiffBuilder.BuildDiffModel(oldText, newText, false);
Assert.NotNull(sideBySideDiffModel);
Assert.Single(sideBySideDiffModel.OldText.Lines);
Assert.Single(sideBySideDiffModel.NewText.Lines);
Assert.True(sideBySideDiffModel.OldText.HasDifferences);
Assert.True(sideBySideDiffModel.NewText.HasDifferences);
}
private void ShowDiffs(string oldText, string newText)
{
IDiffer differ = new Differ();
DiffResult diffResult = differ.CreateLineDiffs(oldText, newText, false);
ISideBySideDiffBuilder diffBuilder = new SideBySideDiffBuilder(differ);
SideBySideDiffModel model = diffBuilder.BuildDiffModel(oldText, newText);
this.DisplayDiffPiece(this.rtbSnapshotLeft, model.OldText.Lines, string.IsNullOrEmpty(newText));
this.DisplayDiffPiece(this.rtbSnapshotRight, model.NewText.Lines, false);
}
public void ShowDiff(string previous, string newContent)
{
SideBySideDiffModel model = new SideBySideDiffBuilder(new Differ()).BuildDiffModel(previous, newContent);
DisplayInto(StackPanelOldLines, model.OldText);
DisplayInto(StackPanelNewLines, model.NewText);
NoDifferenceView.Visibility = model.NewText.Lines.All(i => i.Type == ChangeType.Unchanged) ? Visibility.Visible : Visibility.Collapsed;
if (NoDifferenceView.Visibility == Visibility.Visible)
{
TextBlockNoDifference.Text = previous == newContent ? "No difference" : "Only whitespace changed";
}
}
internal static string[] DoSideBySideDiff(string SourceText, string DestinationText)
{
string[] Result = new string[3];
Differ DiffMaker = new Differ();
SideBySideDiffBuilder SideBySideDiffer = new SideBySideDiffBuilder(DiffMaker);
SideBySideDiffModel SideBySideDiffResult = SideBySideDiffer.BuildDiffModel(SourceText, DestinationText);
int DiffLevel = IronDiffer.GetLevel(SideBySideDiffResult, SourceText, DestinationText);
Result[0] = FullDiff(SideBySideDiffResult.OldText.Lines);
Result[1] = FullDiff(SideBySideDiffResult.NewText.Lines);
Result[2] = DiffLevel.ToString();
return(Result);
}
private async Task <int> CompareFileContents(KVPair pair)
{
var filePath = Path.Combine(Common.BaseDirectoryFullPath, pair.Key);
if (!File.Exists(filePath))
{
await Console.Error.WriteLineAsync($"File not exist: {filePath}");
return(1);
}
var table = new Table();
table.Expand();
table.HorizontalBorder();
table.BorderColor(Color.Grey74);
table.AddColumn(new TableColumn("Consul".ToSilver(isBold: true)));
table.AddColumn(new TableColumn("Local".ToSilver(isBold: true)));
var fileContent = await File.ReadAllTextAsync(filePath, Encoding.UTF8);
var consulContent = Encoding.UTF8.GetString(pair.Value ?? Array.Empty <byte>());
var diffModel = SideBySideDiffBuilder.Diff(consulContent, fileContent);
var oldLines = diffModel.OldText.Lines;
var newLines = diffModel.NewText.Lines;
var maxRow = Math.Max(newLines.Count, oldLines.Count);
for (var i = 0; i < maxRow; i++)
{
var oldLine = oldLines[i];
var oldDiffPosition = oldLine.Position.HasValue ? oldLine.Position.Value.ToString() : " ";
var oldDiffRow = GenerateDiff(oldLine);
oldDiffRow = $"{oldDiffPosition.ToGrey()} {oldDiffRow}";
var newLine = newLines[i];
var newDiffPosition = newLine.Position.HasValue ? newLine.Position.Value.ToString() : " ";
var newDiffRow = GenerateDiff(newLine);
newDiffRow = $"{newDiffPosition.ToGrey()} {newDiffRow}";
table.AddRow(oldDiffRow, newDiffRow);
}
AnsiConsole.Render(table);
if (diffModel.NewText.HasDifferences || diffModel.OldText.HasDifferences)
{
return(2);
}
return(0);
}
/// <summary>
/// Populate the bottom left and right rich text box with a side-by-side compare.
/// </summary>
private void PerformSideBySideDiff()
{
var builder = SideBySideDiffBuilder.Diff(OldText, NewText);
if (builder.OldText.HasDifferences || builder.NewText.HasDifferences)
{
foreach (var line in builder.OldText.Lines)
{
if (!string.IsNullOrWhiteSpace(richTextBoxSideLeft.Text))
{
richTextBoxSideLeft.AppendText(Environment.NewLine);
}
if (line.SubPieces.Any())
{
foreach (var piece in line.SubPieces)
{
AddText(richTextBoxSideLeft, piece);
}
}
else
{
AddText(richTextBoxSideLeft, line);
}
}
foreach (var line in builder.NewText.Lines)
{
if (!string.IsNullOrWhiteSpace(richTextBoxSideRight.Text))
{
richTextBoxSideRight.AppendText(Environment.NewLine);
}
if (line.SubPieces.Any())
{
foreach (var piece in line.SubPieces)
{
AddText(richTextBoxSideRight, piece);
}
}
else
{
AddText(richTextBoxSideRight, line);
}
}
}
else
{
richTextBoxSideLeft.AppendText(OldText);
richTextBoxSideRight.AppendText(NewText);
}
}
public TextBoxDiffRenderer(Grid leftGrid, TextBox leftBox, Grid rightGrid, TextBox rightBox)
{
this.leftGrid = leftGrid;
this.leftBox = leftBox;
this.rightGrid = rightGrid;
this.rightBox = rightBox;
differ = new SideBySideDiffBuilder(new Differ());
fontInfos = new List <FontInfo> {
new FontInfo("Courier New", 1.466, 6.62, 3.5)
};
LinePaddingOverride = 1.593;
CharacterWidthOverride = 7.2;
currentFont = fontInfos.Single(x => x.FontFamily.Equals(leftBox.FontFamily.Source, StringComparison.OrdinalIgnoreCase));
}
public SideBySideDiff CompareString(string generatedFile, string referenceFile, string filenameA, string filenameB)
{
var generated = generatedFile.TrimEnd();
var reference = referenceFile.TrimEnd();
var diffBuilder = new SideBySideDiffBuilder(new Differ());
var diff = diffBuilder.BuildDiffModel(generated, reference, true);
return(new SideBySideDiff
{
A = filenameA,
B = filenameB,
Diff = diff
});
}
private void compareTreeViewStrings(MyTreeView newTreeView, string newText, MyTreeView oldTreeView, string oldText)
{
ISideBySideDiffBuilder diffBuilder = new SideBySideDiffBuilder(new Differ());
SideBySideDiffModel sideBySideModel = diffBuilder.BuildDiffModel(oldText, newText);
newTreeView.Nodes.Clear();
oldTreeView.Nodes.Clear();
TreeNode newParentNode = newTreeView.Nodes.Add(sideBySideModel.NewText.Lines[0].Text);
TreeNode oldParentNode = oldTreeView.Nodes.Add(sideBySideModel.OldText.Lines[0].Text);
colorTreeView(newParentNode.FullPath, newParentNode, sideBySideModel.NewText.Lines, sideBySideModel.OldText.Lines, 1, true);
colorTreeView(oldParentNode.FullPath, oldParentNode, sideBySideModel.OldText.Lines, sideBySideModel.NewText.Lines, 1, false);
newTreeView.AddLinkedTreeView(oldTreeView);
}
private void ShowChanges(int leftIndex, int rightIndex)
{
if (InvokeRequired)
{
Invoke(new Action <int, int>(ShowChanges), leftIndex, rightIndex);
return;
}
var left = leftIndex == -1 ? string.Empty : revisionProvider.Revisions[leftIndex].GetContent();
var right = revisionProvider.Revisions[rightIndex].GetContent();
var builder = new SideBySideDiffBuilder(new Differ());
var model = builder.BuildDiffModel(left, right);
ChangeStartPositions = ModelToTextBox(model.OldText, rtbLeft, rtbLeftNumbers);
ModelToTextBox(model.NewText, rtbRight, rtbRightNumbers);
lblChanges.Text = ChangeStartPositions.Count + " change" + (ChangeStartPositions.Count == 1 ? string.Empty : "s");
}
public void Will_pass_correct_word_separators_to_constructor_to_create_word_diff()
{
string text = "a\nb\nc\nd\n\n";
string[] textLines = { "a", "b", "c", "d", "" };
char[] chars = { ' ', '.' };
var builder = new SideBySideDiffBuilder(new Differ(), chars);
builder.BuildDiffModel(text, text);
Assert.Equal(builder.WordSeparaters.Length, chars.Length);
foreach (var c in builder.WordSeparaters)
{
Assert.Contains(c, chars);
}
}
private static void InitializeChildRows(CremaDataRow diffRow1, CremaDataRow diffRow2, CremaDataRow dataRow1, CremaDataRow dataRow2, CremaDataTable diffChildTable1, CremaDataTable diffChildTable2, CremaDataTable childTable1, CremaDataTable childTable2)
{
var emptyRows = new CremaDataRow[] { };
var inlineBuilder = new SideBySideDiffBuilder(new Differ());
var childRows1 = dataRow1 != null && childTable1 != null?dataRow1.GetChildRows(childTable1) : emptyRows;
var childRows2 = dataRow2 != null && childTable2 != null?dataRow2.GetChildRows(childTable2) : emptyRows;
var rowText1 = GetString(childRows1);
var rowText2 = GetString(childRows2);
var rowDiff = inlineBuilder.BuildDiffModel(rowText1, rowText2);
FillChildRow(diffRow1, dataRow1, diffChildTable1, childTable1, childRows1, rowDiff.OldText.Lines);
FillChildRow(diffRow2, dataRow2, diffChildTable2, childTable2, childRows2, rowDiff.NewText.Lines);
}
public void ThenCompareWithDiffPlexTheFollowngFilesVs(string fileOne, string fileTwo)
{
string str1 = FileStorage.ReadFileText(fileOne.StrVar());
string str2 = FileStorage.ReadFileText(fileTwo.StrVar());
var d1 = new Differ();
var sidebYSide = new SideBySideDiffBuilder(d1);
var result1 = sidebYSide.BuildDiffModel(str1, str2);
foreach (var line in result1.NewText.Lines)
{
if (line.Type == ChangeType.Modified)
{
Assert.Fail(line.Position + " " + line.Text);
}
}
}
public static void Run()
{
var txt1 = Resources.oldState;
var txt2 = Resources.newState;
var diff = InlineDiffBuilder.Diff(txt1, txt2);
var diff2 = SideBySideDiffBuilder.Diff(txt1, txt2);
var savedColor = Console.ForegroundColor;
_printLines(diff2.OldText.Lines);
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("-------------------------------------------");
_printLines(diff2.NewText.Lines);
Console.ForegroundColor = savedColor;
}
public void Report(string approved, string received)
{
var approvedText = File.ReadAllText(approved);
var receivedText = File.ReadAllText(received);
var diffBuilder = new SideBySideDiffBuilder(new Differ());
var diff = diffBuilder.BuildDiffModel(approvedText, receivedText);
var sb = new StringBuilder()
.AppendLine($"<<<<<<<<< {Path.GetFileName(approved)}")
.AppendDiff(diff.OldText)
.AppendLine("=========")
.AppendDiff(diff.NewText)
.Append($">>>>>>>>> {Path.GetFileName(received)}");
//_out.WriteLine(sb.ToString());
throw new ApiNotApprovedException(sb.ToString());
}
public ActionResult Index(int id, List <int> grSel)
{
var db = new ZkDataContext();
var post = db.ForumPosts.Find(id);
string txt1 = "";
string txt2 = "";
if (grSel != null && grSel.Any())
{
if (grSel.Count > 1)
{
txt1 = db.ForumPostEdits.Find(grSel.Min())?.NewText;
txt2 = db.ForumPostEdits.Find(grSel.Max())?.NewText;
}
else
{
var edit = db.ForumPostEdits.Find(grSel.First());
if (edit != null)
{
txt1 = edit.OriginalText;
txt2 = edit.NewText;
}
}
var sd = new SideBySideDiffBuilder(new Differ());
ViewBag.DiffModel = sd.BuildDiffModel(txt1, txt2);
}
else
{
var edit = post.ForumPostEdits.OrderByDescending(x => x.ForumPostEditID).FirstOrDefault();
if (edit != null)
{
var sd = new SideBySideDiffBuilder(new Differ());
ViewBag.DiffModel = sd.BuildDiffModel(edit.OriginalText, edit.NewText);
}
}
return(View("PostHistoryIndex", post));
}
public void Will_build_diffModel_for_partially_different_lines()
{
string textOld = "m is h";
string textNew = "m ai is n h";
string[] textLinesOld = { "m is h" };
string[] textLinesNew = { "m ai is n h" };
var differ = new Mock <IDiffer>();
differ.Setup(x => x.CreateDiffs(textOld, textNew, true, false, It.IsNotNull <IChunker>()))
.Returns(new DiffResult(textLinesOld, textLinesNew, new List <DiffBlock> {
new DiffBlock(0, 1, 0, 1)
}));
differ.Setup(x => x.CreateDiffs(It.IsAny <string>(), It.IsAny <string>(), false, false, It.IsNotNull <IChunker>()))
.Returns(new DiffResult(
new[] { "m ", "is ", "h" },
new[] { "m ", "ai ", "is ", "n ", "h" },
new List <DiffBlock> {
new DiffBlock(1, 0, 1, 1), new DiffBlock(3, 0, 3, 1)
}));
var builder = new SideBySideDiffBuilder(differ.Object);
var bidiff = builder.BuildDiffModel(textOld, textNew);
Assert.NotNull(bidiff);
Assert.Single(bidiff.OldText.Lines);
Assert.Single(bidiff.NewText.Lines);
Assert.Equal(ChangeType.Unchanged, bidiff.NewText.Lines[0].SubPieces[0].Type);
Assert.Equal(ChangeType.Inserted, bidiff.NewText.Lines[0].SubPieces[1].Type);
Assert.Equal(ChangeType.Unchanged, bidiff.NewText.Lines[0].SubPieces[2].Type);
Assert.Equal(ChangeType.Inserted, bidiff.NewText.Lines[0].SubPieces[3].Type);
Assert.Equal(ChangeType.Unchanged, bidiff.NewText.Lines[0].SubPieces[4].Type);
Assert.Equal(ChangeType.Unchanged, bidiff.OldText.Lines[0].SubPieces[0].Type);
Assert.Equal(ChangeType.Imaginary, bidiff.OldText.Lines[0].SubPieces[1].Type);
Assert.Equal(ChangeType.Unchanged, bidiff.OldText.Lines[0].SubPieces[2].Type);
Assert.Equal(ChangeType.Imaginary, bidiff.OldText.Lines[0].SubPieces[3].Type);
Assert.Equal(ChangeType.Unchanged, bidiff.OldText.Lines[0].SubPieces[4].Type);
Assert.True(bidiff.OldText.HasDifferences && bidiff.NewText.HasDifferences);
}
public virtual ActionResult Diff(string folderName, string parentFolder, string uuid, string version)
{
TextFolder textFolder = new TextFolder(Repository, folderName).AsActual();
var schema = textFolder.GetSchema().AsActual();
var versions = version.Split(',');
var v1 = int.Parse(versions[0]);
var v2 = int.Parse(versions[1]);
var textContent = schema.CreateQuery().WhereEquals("UUID", uuid).FirstOrDefault();
var version1 = VersionManager.GetVersion(textContent, v1);
var version1Content = new TextContent(version1.TextContent);
var version2 = VersionManager.GetVersion(textContent, v2);
var version2Content = new TextContent(version2.TextContent);
var sideBySideDiffBuilder = new SideBySideDiffBuilder(new Differ());
var model = new TextContentDiffModel()
{
UUID = uuid, Version1Name = v1, Version2Name = v2
};
foreach (var k in textContent.Keys)
{
var version1Text = version1Content[k] != null ? version1Content[k].ToString() : "";
var version2Text = version2Content[k] != null ? version2Content[k].ToString() : "";
var diffModel = sideBySideDiffBuilder.BuildDiffModel(version1Text, version2Text);
model.Version1.Add(k, diffModel.OldText);
model.Version2.Add(k, diffModel.NewText);
}
return(View(model));
}
public async void CheckForChanges()
{
DataContract.FileInfo info = FileInfo;
//check the fileinfo data
if (info == null) return;
//If the file exists
if (!File.Exists(info.Filename)) return;
//If the file was modified after the last modification date
if (File.GetLastWriteTime(info.Filename) <= info.LastModifiedDate) return;
//Then we can show a message
MessageDialogResult Result = await (new ViewModelLocator())
.Main.ShowFileChangedDialog();
if (Result == MessageDialogResult.Affirmative)
{
string oldText = ScriptParser.ParseScriptForCompare(this);
string newText = ScriptParser.ParseScriptFileForCompare(info.Filename);
SideBySideDiffModel model = new SideBySideDiffBuilder(
new Differ()).BuildDiffModel(oldText, newText);
new ViewModelLocator().CodeComparator.DiffModel = model;
new CompareCode().ShowDialog();
}
}
public void Will_build_diffModel_when_oldText_is_empty()
{
string textOld = "";
string textNew = "z\ny\nx\nw\n";
string[] textLinesOld = {};
string[] textLinesNew = { "z", "y" };
var differ = new Mock <IDiffer>();
differ.Setup(x => x.CreateDiffs(textOld, textNew, true, false, It.IsNotNull <IChunker>()))
.Returns(new DiffResult(textLinesOld, textLinesNew, new List <DiffBlock> {
new DiffBlock(0, 0, 0, 2)
}));
differ.Setup(x => x.CreateDiffs(It.IsAny <string>(), It.IsAny <string>(), false, false, It.IsNotNull <IChunker>()))
.Returns(new DiffResult(new string[0], new string[0], new List <DiffBlock>()));
var builder = new SideBySideDiffBuilder(differ.Object);
var bidiff = builder.BuildDiffModel(textOld, textNew);
Assert.NotNull(bidiff);
Assert.Equal(2, bidiff.OldText.Lines.Count);
Assert.Equal(2, bidiff.NewText.Lines.Count);
for (int j = 0; j < textLinesNew.Length; j++)
{
Assert.Equal(textLinesNew[j], bidiff.NewText.Lines[j].Text);
Assert.Equal(ChangeType.Inserted, bidiff.NewText.Lines[j].Type);
Assert.Equal(j + 1, bidiff.NewText.Lines[j].Position);
Assert.Null(bidiff.OldText.Lines[j].Text);
Assert.Equal(ChangeType.Imaginary, bidiff.OldText.Lines[j].Type);
Assert.False(bidiff.OldText.Lines[j].Position.HasValue);
}
Assert.True(bidiff.OldText.HasDifferences && bidiff.NewText.HasDifferences);
}
public static IEnumerable <FileDifferences> CompareFileContent(string oldFileContent, string newFileContent)
{
if (oldFileContent == null || newFileContent == null)
{
Trace.WriteLine("One of the file content is null");
return(null);
}
if (oldFileContent == newFileContent)
{
Trace.WriteLine("Files are identical");
return(null);
}
const string matchText = "<tr><th>Coverage:</th><td>0%</td></tr>";
if (oldFileContent.Contains(matchText) && newFileContent.Contains(matchText))
{
Trace.WriteLine("Both files have no coverage.");
return(null);
}
oldFileContent = RemoveLineNumbers(oldFileContent);
newFileContent = RemoveLineNumbers(newFileContent);
SideBySideDiffBuilder sideBySideDiffer = new SideBySideDiffBuilder(new Differ());
SideBySideDiffModel diff = sideBySideDiffer.BuildDiffModel(oldFileContent, newFileContent);
DiffPiece[] newLines = diff.NewText.Lines.Where(DoesLineHaveDifferentCoverage).ToArray();
if (!diff.OldText.Lines.Where(DoesLineHaveDifferentCoverage).Concat(newLines).Any())
{
Trace.WriteLine("No changes to code coverage");
return(null);
}
return(AnalyzeDiff(diff, newLines));
}
private void Row_DoubleClick(object sender, MouseButtonEventArgs e)
{
// execute some code
DataGridRow r = (DataGridRow)sender;
dynamic i = r.Item;
FHXCompareResult rs = i.Value;
var diffBuilder = new SideBySideDiffBuilder(new Differ());
if (rs.NewValue == null)
{
this.tbOld.Document.Blocks.Clear();
this.tbNew.Document.Blocks.Clear();
var p = new Paragraph();
var tr = new TextRange(p.ContentStart, p.ContentEnd);
tr.Text = rs.OldValue;
this.tbOld.Document.Blocks.Add(p);
}
else
{
var diff = diffBuilder.BuildDiffModel(rs.OldValue, rs.NewValue);
RichTextBox[] tb = new RichTextBox[2] {
this.tbOld, this.tbNew
};
List <DiffPiece>[] t = new List <DiffPiece>[2] {
diff.OldText.Lines, diff.NewText.Lines
};
for (int j = 0; j < 2; j++)
{
tb[j].Document.Blocks.Clear();
foreach (DiffPiece line in t[j])
{
var p = new Paragraph();
p.Margin = new Thickness(0);
TextRange tr;
tr = new TextRange(p.ContentStart, p.ContentEnd);
switch (line.Type)
{
case ChangeType.Inserted:
tr.Text = line.Text;
tr.ApplyPropertyValue(TextElement.BackgroundProperty, Brushes.LightGreen);
break;
case ChangeType.Deleted:
tr.Text = line.Text;
tr.ApplyPropertyValue(TextElement.BackgroundProperty, Brushes.LightPink);
break;
case ChangeType.Modified:
tr.Text = line.Text;
tr.ApplyPropertyValue(TextElement.BackgroundProperty, Brushes.Goldenrod);
break;
case ChangeType.Imaginary:
tr.Text = " ";
tr.ApplyPropertyValue(TextElement.BackgroundProperty, Brushes.Gray);
break;
case ChangeType.Unchanged:
tr.Text = line.Text;
tr.ApplyPropertyValue(TextElement.ForegroundProperty, Brushes.Black);
break;
default:
tr.Text = line.Text;
tr.ApplyPropertyValue(TextElement.ForegroundProperty, Brushes.White);
break;
}
tb[j].Document.Blocks.Add(p);
}
}
}
}
public void Will_build_diffModel_for_partially_different_documents()
{
string textOld = "1\n2\na\nb\nc\nd\n\n";
string textNew = "1\n2\nz\ny\nx\nw\n";
string[] textLinesOld = { "1", "2", "a", "b", "c", "d", "" };
string[] textLinesNew = { "1", "2", "z", "y", "x", "w" };
var differ = new Mock <IDiffer>();
differ.Setup(x => x.CreateLineDiffs(textOld, textNew, true))
.Returns(new DiffResult(textLinesOld, textLinesNew, new List <DiffBlock> {
new DiffBlock(2, 5, 2, 4)
}));
differ.Setup(x => x.CreateWordDiffs(It.IsAny <string>(), It.IsAny <string>(), false, It.IsAny <char[]>()))
.Returns(new DiffResult(new string[0], new string[0], new List <DiffBlock>()));
var builder = new SideBySideDiffBuilder(differ.Object);
var bidiff = builder.BuildDiffModel(textOld, textNew);
Assert.NotNull(bidiff);
Assert.Equal(7, bidiff.OldText.Lines.Count);
Assert.Equal(7, bidiff.NewText.Lines.Count);
int i = 0;
for (; i < 2; i++)
{
Assert.Equal(textLinesNew[i], bidiff.NewText.Lines[i].Text);
Assert.Equal(ChangeType.Unchanged, bidiff.NewText.Lines[i].Type);
Assert.Equal(i + 1, bidiff.NewText.Lines[i].Position);
Assert.Equal(textLinesOld[i], bidiff.OldText.Lines[i].Text);
Assert.Equal(ChangeType.Unchanged, bidiff.OldText.Lines[i].Type);
Assert.Equal(i + 1, bidiff.OldText.Lines[i].Position);
}
for (; i < Math.Min(textLinesOld.Length, textLinesNew.Length); i++)
{
Assert.Equal(textLinesOld[i], bidiff.OldText.Lines[i].Text);
Assert.Equal(ChangeType.Modified, bidiff.OldText.Lines[i].Type);
Assert.Equal(i + 1, bidiff.OldText.Lines[i].Position);
Assert.Equal(textLinesNew[i], bidiff.NewText.Lines[i].Text);
Assert.Equal(ChangeType.Modified, bidiff.NewText.Lines[i].Type);
Assert.Equal(i + 1, bidiff.NewText.Lines[i].Position);
}
if (textLinesOld.Length < textLinesNew.Length)
{
for (int j = i; j < textLinesNew.Length; j++)
{
Assert.Equal(textLinesNew[j], bidiff.NewText.Lines[j].Text);
Assert.Equal(ChangeType.Inserted, bidiff.NewText.Lines[j].Type);
Assert.Equal(j + 1, bidiff.NewText.Lines[j].Position);
Assert.Null(bidiff.OldText.Lines[j].Text);
Assert.Equal(ChangeType.Imaginary, bidiff.OldText.Lines[j].Type);
Assert.False(bidiff.OldText.Lines[j].Position.HasValue);
}
}
else
{
for (int j = i; j < textLinesOld.Length; j++)
{
Assert.Equal(textLinesOld[j], bidiff.OldText.Lines[j].Text);
Assert.Equal(ChangeType.Deleted, bidiff.OldText.Lines[j].Type);
Assert.Equal(j + 1, bidiff.OldText.Lines[j].Position);
Assert.Null(bidiff.NewText.Lines[j].Text);
Assert.Equal(ChangeType.Imaginary, bidiff.NewText.Lines[j].Type);
Assert.False(bidiff.NewText.Lines[j].Position.HasValue);
}
}
}
public void Can_compare_whitespace()
{
string textOld = "1\n 2\n3 \n 4 \n5";
string textNew = "1\n2\n3\n4\n5";
var builder = new SideBySideDiffBuilder(new Differ());
var model = builder.BuildDiffModel(textOld, textNew, ignoreWhitespace: false);
Assert.Equal(
model.OldText.Lines,
new DiffPiece[]
{
new DiffPiece("1", ChangeType.Unchanged, 1),
new DiffPiece(" 2", ChangeType.Modified, 2)
{
SubPieces =
{
new DiffPiece("", ChangeType.Deleted, 1),
new DiffPiece(" ", ChangeType.Deleted, 2),
new DiffPiece("2", ChangeType.Unchanged, 3),
},
},
new DiffPiece("3 ", ChangeType.Modified, 3)
{
SubPieces =
{
new DiffPiece("3", ChangeType.Unchanged, 1),
new DiffPiece(" ", ChangeType.Deleted, 2),
},
},
new DiffPiece(" 4 ", ChangeType.Modified, 4)
{
SubPieces =
{
new DiffPiece("", ChangeType.Deleted, 1),
new DiffPiece(" ", ChangeType.Deleted, 2),
new DiffPiece("4", ChangeType.Unchanged, 3),
new DiffPiece(" ", ChangeType.Deleted, 4),
},
},
new DiffPiece("5", ChangeType.Unchanged, 5),
});
Assert.Equal(
model.NewText.Lines,
new DiffPiece[]
{
new DiffPiece("1", ChangeType.Unchanged, 1),
new DiffPiece("2", ChangeType.Modified, 2)
{
SubPieces =
{
new DiffPiece(null, ChangeType.Imaginary),
new DiffPiece(null, ChangeType.Imaginary),
new DiffPiece("2", ChangeType.Unchanged,1),
},
},
new DiffPiece("3", ChangeType.Modified, 3)
{
SubPieces =
{
new DiffPiece("3", ChangeType.Unchanged, 1),
new DiffPiece(null, ChangeType.Imaginary),
},
},
new DiffPiece("4", ChangeType.Modified, 4)
{
SubPieces =
{
new DiffPiece(null, ChangeType.Imaginary),
new DiffPiece(null, ChangeType.Imaginary),
new DiffPiece("4", ChangeType.Unchanged,1),
new DiffPiece(null, ChangeType.Imaginary),
},
},
new DiffPiece("5", ChangeType.Unchanged, 5),
});
}
public static SideBySideDiffModel DiffText(string t1, string t2)
{
return(SideBySideDiffBuilder.Diff(t1, t2));
}
public RichTextBlockDiffRenderer()
{
differ = new SideBySideDiffBuilder(new Differ());
}
/// <summary>
/// 差分比較情報を作成
/// </summary>
private SideBySideDiffModel CreateDiff()
{
var diff = new SideBySideDiffBuilder(new Differ());
return(diff.BuildDiffModel(pathModel.InputFileName, pathModel.OutputFileName));
}
