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)); }