Example #1
0
        public void BothChangedSame()
        {
            var left = DiffFactory.Create <Dictionary <string, Sample> >().KeyValue()
                       .Changed("a", inner => inner.Class()
                                .Replaced(x => x.Value, "a", "b")
                                )
                       .MakeDiff();
            var right = DiffFactory.Create <Dictionary <string, Sample> >().KeyValue()
                        .Changed("a", inner => inner.Class()
                                 .Replaced(x => x.Value, "a", "b")
                                 )
                        .MakeDiff();

            IConflictContainer conflicts;
            var result = Merger.Instance.Partial.MergeDiffs(left, right, out conflicts);

            var merged = DiffFactory.Create <Dictionary <string, Sample> >().KeyValue()
                         .Changed("a", inner => inner.Class()
                                  .Replaced(x => x.Value, "a", "b")
                                  )
                         .MakeDiff();

            Assert.AreEqual(merged, result);
            Assert.IsFalse(conflicts.HasConflicts);
        }
Example #2
0
        public void OneConflictUseLeft()
        {
            var diffConflicted = DiffFactory.Create <Sample>().Class()
                                 .Changed(x => x.ValueInner, inner => inner.Class()
                                          .Conflicted(
                                              c => c.Replaced(x => x.Value, "a", "b"),
                                              c => c.Replaced(x => x.Value, "a", "c")
                                              )
                                          )
                                 .MakeDiff();

            var diffResolved = DiffFactory.Create <Sample>().Class()
                               .Changed(x => x.ValueInner, inner => inner.Class()
                                        .Replaced(x => x.Value, "a", "b")
                                        )
                               .MakeDiff();

            var conflictResolver = Merger.Instance.Partial.GetConflictResolver(diffConflicted);

            Assert.IsTrue(conflictResolver.HasConflicts);

            IDiffItemConflicted[] conflicts = conflictResolver.ToArray();
            Assert.AreEqual(1, conflicts.Length);

            conflictResolver.ResolveConflict(conflicts[0], ResolveAction.UseLeft);

            Assert.IsFalse(conflictResolver.HasConflicts);
            Assert.AreEqual(diffResolved, conflictResolver.Finish());
        }
Example #3
0
        public void MergeObjectConflictDescendants()
        {
            var left = DiffFactory.Create <SampleBase>().Value()
                       .ChangedType <SampleDescendant1>(inner => inner.Class()
                                                        .Replaced(x => x.ValueBase, "a", "b")
                                                        )
                       .MakeDiff();
            var right = DiffFactory.Create <SampleBase>().Value()
                        .ChangedType <SampleDescendant1>(inner => inner.Class()
                                                         .Replaced(x => x.ValueBase, "a", "c")
                                                         )
                        .MakeDiff();

            IConflictContainer conflicts;
            var result = Merger.Instance.Partial.MergeDiffs(left, right, out conflicts);

            var merged = DiffFactory.Create <SampleBase>().Value()
                         .ChangedType <SampleDescendant1>(inner => inner.Class()
                                                          .Conflicted(
                                                              c => c.Replaced(x => x.ValueBase, "a", "b"),
                                                              c => c.Replaced(x => x.ValueBase, "a", "c")
                                                              )
                                                          )
                         .MakeDiff();

            Assert.AreEqual(merged, result);
            Assert.IsTrue(conflicts.HasConflicts);
        }
Example #4
0
        public void TestArrayReplaced()
        {
            var @base = new[]
            {
                new SampleInner {
                    Id = 1, Value = "a"
                },
                new SampleInner {
                    Id = 2, Value = "b"
                }
            };
            var changed = new[]
            {
                new SampleInner {
                    Id = 1, Value = "a"
                },
                new SampleInner {
                    Id = 2, Value = "a"
                }
            };

            var expected = DiffFactory.Create <SampleInner[]>().Ordered()
                           .Replaced(1, new SampleInner {
                Id = 2, Value = "b"
            }, new SampleInner {
                Id = 2, Value = "a"
            })
                           .MakeDiff();

            var ret = Merger.Instance.Partial.Diff(@base, changed);

            Assert.AreEqual(expected, ret);
        }
Example #5
0
        public void BothSidesAddedTwo()
        {
            var left = DiffFactory.Create <int[]>().Ordered()
                       .Added(3, 3)
                       .Added(3, 4)
                       .MakeDiff();
            var right = DiffFactory.Create <int[]>().Ordered()
                        .Added(3, 5)
                        .Added(3, 6)
                        .MakeDiff();

            IConflictContainer conflicts;
            var result = Merger.Instance.Partial.MergeDiffs(left, right, out conflicts);

            var merged = DiffFactory.Create <int[]>().Ordered()
                         .Conflicted(
                c => c
                .Added(3, 3)
                .Added(3, 4),
                c => c
                .Added(3, 5)
                .Added(3, 6)
                )
                         .MakeDiff();

            Assert.AreEqual(merged, result);
            Assert.IsTrue(conflicts.HasConflicts);
        }
Example #6
0
        public void OneRemoved()
        {
            var @base = new[]
            {
                new Sample {
                    Id = 0, Value = "a"
                },
                new Sample {
                    Id = 1, Value = "a"
                },
                new Sample {
                    Id = 2, Value = "b"
                }
            };
            var changed = new[]
            {
                new Sample {
                    Id = 1, Value = "a"
                },
                new Sample {
                    Id = 2, Value = "b"
                }
            };

            var expected = DiffFactory.Create <Sample[]>().Ordered()
                           .Removed(0, new Sample {
                Id = 0, Value = "a"
            })
                           .MakeDiff();

            var ret = Merger.Instance.Partial.Diff(@base, changed);

            Assert.AreEqual(expected, ret);
        }
Example #7
0
        public void TestDictionaryReplaced()
        {
            var @base = new Dictionary <string, SampleInner>
            {
                { "a", new SampleInner {
                      Id = 1, Value = "a"
                  } },
                { "b", new SampleInner {
                      Id = 2, Value = "b"
                  } }
            };
            var changed = new Dictionary <string, SampleInner>
            {
                { "a", new SampleInner {
                      Id = 1, Value = "a"
                  } },
                { "b", new SampleInner {
                      Id = 2, Value = "a"
                  } }
            };

            var expected = DiffFactory.Create <Dictionary <string, SampleInner> >().KeyValue()
                           .Replaced("b", new SampleInner {
                Id = 2, Value = "b"
            }, new SampleInner {
                Id = 2, Value = "a"
            })
                           .MakeDiff();

            var ret = Merger.Instance.Partial.Diff(@base, changed);

            Assert.AreEqual(expected, ret);
        }
Example #8
0
        public void Set()
        {
            var diff = DiffFactory.Create <HashSet <SampleInner> >().Unordered()
                       .Changed(1, inner => inner.Class()
                                .Replaced(x => x.Value, "Hello", "World")
                                )
                       .Replaced(new SampleInner(), new SampleInner())
                       .Removed(new SampleInner())
                       .Added(new SampleInner())
                       .Unchanged(new SampleInner())
                       .MakeDiff();

            var expected = new StringBuilder();

            expected.AppendLine("=1:");
            expected.AppendLine("\t-Value:Hello");
            expected.AppendLine("\t+Value:World");
            expected.AppendLine("-<SampleInner>");
            expected.AppendLine("+<SampleInner>");
            expected.AppendLine("-<SampleInner>");
            expected.AppendLine("+<SampleInner>");
            expected.Append(" <SampleInner>");

            Assert.AreEqual(expected.ToString(), diff.ToString());
        }
Example #9
0
        public void OneRemoved()
        {
            var diff = DiffFactory.Create <HashSet <Sample> >().Unordered()
                       .Removed(new Sample {
                Id = 3, Value = "c"
            })
                       .MakeDiff();

            var obj = new HashSet <Sample>
            {
                new Sample {
                    Id = 1, Value = "a"
                },
                new Sample {
                    Id = 2, Value = "b"
                },
                new Sample {
                    Id = 3, Value = "c"
                }
            };
            var changed = new HashSet <Sample>
            {
                new Sample {
                    Id = 1, Value = "a"
                },
                new Sample {
                    Id = 2, Value = "b"
                }
            };

            var ret = Merger.Instance.Partial.ApplyPatch(obj, diff);

            CollectionAssert.AreEqual(changed.OrderBy(x => x.Id).ToArray(), ret.ToArray());
        }
Example #10
0
        public void Array()
        {
            var diff = DiffFactory.Create <SampleInner[]>().Ordered()
                       .Changed(0, inner => inner.Class()
                                .Replaced(x => x.Value, "Hello", "World")
                                )
                       .Replaced(1, new SampleInner(), new SampleInner())
                       .Removed(2, new SampleInner())
                       .Added(2, new SampleInner())
                       .Unchanged(3, new SampleInner())
                       .MakeDiff();

            var expected = new StringBuilder();

            expected.AppendLine("=0:");
            expected.AppendLine("\t-Value:Hello");
            expected.AppendLine("\t+Value:World");
            expected.AppendLine("-1:<SampleInner>");
            expected.AppendLine("+1:<SampleInner>");
            expected.AppendLine("-2:<SampleInner>");
            expected.AppendLine("+2:<SampleInner>");
            expected.Append(" 3:<SampleInner>");

            Assert.AreEqual(expected.ToString(), diff.ToString());
        }
Example #11
0
        public void Dictionary()
        {
            var diff = DiffFactory.Create <Dictionary <string, SampleInner> >().KeyValue()
                       .Changed("a", inner => inner.Class()
                                .Replaced(x => x.Value, "Hello", "World")
                                )
                       .Replaced("b", new SampleInner(), new SampleInner())
                       .Removed("c", new SampleInner())
                       .Added("d", new SampleInner())
                       .Unchanged("e", new SampleInner())
                       .MakeDiff();

            var expected = new StringBuilder();

            expected.AppendLine("=a:");
            expected.AppendLine("\t-Value:Hello");
            expected.AppendLine("\t+Value:World");
            expected.AppendLine("-b:<SampleInner>");
            expected.AppendLine("+b:<SampleInner>");
            expected.AppendLine("-c:<SampleInner>");
            expected.AppendLine("+d:<SampleInner>");
            expected.Append(" e:<SampleInner>");

            Assert.AreEqual(expected.ToString(), diff.ToString());
        }
Example #12
0
        public void MergeNonConflictingRightItemLast()
        {
            var left = DiffFactory.Create <Sample>().Class()
                       .Replaced(x => x.Value, "a", "b")
                       .MakeDiff();
            var right = DiffFactory.Create <Sample>().Class()
                        .Replaced(x => x.Value2, "a", "b")
                        .Changed(x => x.ValueInner, inner => inner.Class()
                                 .Replaced(x => x.Value, "a", "b")
                                 )
                        .MakeDiff();

            IConflictContainer conflicts;
            var result = Merger.Instance.Partial.MergeDiffs(left, right, out conflicts);

            var merged = DiffFactory.Create <Sample>().Class()
                         .Replaced(x => x.Value, "a", "b")
                         .Replaced(x => x.Value2, "a", "b")
                         .Changed(x => x.ValueInner, inner => inner.Class()
                                  .Replaced(x => x.Value, "a", "b")
                                  )
                         .MakeDiff();

            Assert.AreEqual(merged, result);
            Assert.IsFalse(conflicts.HasConflicts);
        }
Example #13
0
        public static async Task <List <Diff> > GenerateDiffCache(string fileA, string fileB)
        {
            if (string.IsNullOrEmpty(fileA) || string.IsNullOrEmpty(fileB))
            {
                return(new List <Diff>());
            }

            fileA = fileA.Replace("/", "\\");
            fileB = fileB.Replace("/", "\\");

            var fileAFolder = await StorageFolder.GetFolderFromPathAsync(
                fileA.Substring(0, fileA.LastIndexOf('\\')));

            var fileBFolder = await StorageFolder.GetFolderFromPathAsync(
                fileB.Substring(0, fileB.LastIndexOf('\\')));

            var fileAFile = await fileAFolder.GetFileAsync(FileHelper.GetFileName(fileA));

            var fileBFile = await fileBFolder.GetFileAsync(FileHelper.GetFileName(fileB));

            var fileAText = await Windows.Storage.FileIO.ReadTextAsync(fileAFile);

            var fileBText = await Windows.Storage.FileIO.ReadTextAsync(fileBFile);

            fileAText = fileAText.Replace("\r\n", "\n");
            fileBText = fileBText.Replace("\r\n", "\n");

            return(DiffFactory.GenerateDiffCache(fileAText, fileBText));
        }
Example #14
0
        public void BothAddedDifferent()
        {
            var left = DiffFactory.Create <Dictionary <string, Sample> >().KeyValue()
                       .Added("a", new Sample {
                Id = 1
            })
                       .MakeDiff();
            var right = DiffFactory.Create <Dictionary <string, Sample> >().KeyValue()
                        .Added("a", new Sample {
                Id = 2
            })
                        .MakeDiff();

            IConflictContainer conflicts;
            var result = Merger.Instance.Partial.MergeDiffs(left, right, out conflicts);

            var merged = DiffFactory.Create <Dictionary <string, Sample> >().KeyValue()
                         .Conflicted(
                c => c.Added("a", new Sample {
                Id = 1
            }),
                c => c.Added("a", new Sample {
                Id = 2
            })
                )
                         .MakeDiff();

            Assert.AreEqual(merged, result);
            Assert.IsTrue(conflicts.HasConflicts);
        }
Example #15
0
        public void BothChanged()
        {
            var left = DiffFactory.Create <Sample[]>().Ordered()
                       .Changed(5, inner => inner.Class()
                                .Replaced(x => x.Value, "a", "b")
                                )
                       .MakeDiff();
            var right = DiffFactory.Create <Sample[]>().Ordered()
                        .Changed(5, inner => inner.Class()
                                 .Replaced(x => x.Value, "a", "c")
                                 )
                        .MakeDiff();

            IConflictContainer conflicts;
            var result = Merger.Instance.Partial.MergeDiffs(left, right, out conflicts);

            var merged = DiffFactory.Create <Sample[]>().Ordered()
                         .Changed(5, inner => inner.Class()
                                  .Conflicted(
                                      c => c.Replaced(x => x.Value, "a", "b"),
                                      c => c.Replaced(x => x.Value, "a", "c")
                                      )
                                  )
                         .MakeDiff();

            Assert.AreEqual(merged, result);
            Assert.IsTrue(conflicts.HasConflicts);
        }
Example #16
0
        public void ConflictRemovedRemovedThenReplacedUseLeft()
        {
            var diffConflicted = DiffFactory.Create <int[]>().Ordered()
                                 .Conflicted(
                c => c.Removed(0, 0),
                c => c.Replaced(0, 0, 5)
                )
                                 .Removed(1, 1)
                                 .Replaced(2, 3, 5)
                                 .MakeDiff();

            var diffResolved = DiffFactory.Create <int[]>().Ordered()
                               .Removed(0, 0)
                               .Removed(1, 1)
                               .Replaced(2, 3, 5)
                               .MakeDiff();

            var conflictResolver = Merger.Instance.Partial.GetConflictResolver(diffConflicted);

            Assert.IsTrue(conflictResolver.HasConflicts);

            IDiffItemConflicted[] conflicts = conflictResolver.ToArray();
            Assert.AreEqual(1, conflicts.Length);

            conflictResolver.ResolveConflict(conflicts[0], ResolveAction.UseLeft);

            Assert.IsFalse(conflictResolver.HasConflicts);
            Assert.AreEqual(diffResolved, conflictResolver.Finish());
        }
Example #17
0
        public void OneChanged()
        {
            var @base = new[]
            {
                new Sample {
                    Id = 1, Value = "a"
                },
                new Sample {
                    Id = 2, Value = "b"
                }
            };
            var changed = new[]
            {
                new Sample {
                    Id = 1, Value = "c"
                },
                new Sample {
                    Id = 2, Value = "b"
                }
            };

            var expected = DiffFactory.Create <Sample[]>().Ordered()
                           .Changed(0, inner => inner.Class()
                                    .Replaced(x => x.Value, "a", "c")
                                    )
                           .MakeDiff();

            var ret = Merger.Instance.Partial.Diff(@base, changed);

            Assert.AreEqual(expected, ret);
        }
Example #18
0
        public void OneReplacedWithOtherDescendant()
        {
            var @base = new SampleBase[]
            {
                new SampleDescendant1 {
                    Id = 1, Value = "a"
                },
                new SampleDescendant1 {
                    Id = 2, Value = "b"
                }
            };
            var changed = new SampleBase[]
            {
                new SampleDescendant1 {
                    Id = 1, Value = "a"
                },
                new SampleDescendant2 {
                    Id = 2, Value = "b"
                }
            };

            var expected = DiffFactory.Create <SampleBase[]>().Ordered()
                           .Changed(1, inner => inner.Value()
                                    .Replaced(new SampleDescendant1 {
                Id = 2, Value = "b"
            }, new SampleDescendant2 {
                Id = 2, Value = "b"
            })
                                    )
                           .MakeDiff();

            var ret = Merger.Instance.Partial.Diff(@base, changed);

            Assert.AreEqual(expected, ret);
        }
Example #19
0
        public void TestSetReplaced()
        {
            var @base = new HashSet <SampleInner>
            {
                new SampleInner {
                    Id = 1, Value = "a"
                },
                new SampleInner {
                    Id = 2, Value = "b"
                }
            };
            var changed = new HashSet <SampleInner>
            {
                new SampleInner {
                    Id = 1, Value = "a"
                },
                new SampleInner {
                    Id = 2, Value = "a"
                }
            };

            var expected = DiffFactory.Create <HashSet <SampleInner> >().Unordered()
                           .Replaced(new SampleInner {
                Id = 2, Value = "b"
            }, new SampleInner {
                Id = 2, Value = "a"
            })
                           .MakeDiff();

            var ret = Merger.Instance.Partial.Diff(@base, changed);

            Assert.AreEqual(expected, ret);
        }
Example #20
0
        public void OneChangedProperty()
        {
            var @base = new SampleBase[]
            {
                new SampleDescendant1 {
                    Id = 1, Value = "a"
                },
                new SampleDescendant1 {
                    Id = 2, Value = "b"
                }
            };
            var changed = new SampleBase[]
            {
                new SampleDescendant1 {
                    Id = 1, Value = "a"
                },
                new SampleDescendant1 {
                    Id = 2, Value = "c"
                }
            };

            var expected = DiffFactory.Create <SampleBase[]>().Ordered()
                           .Changed(1, inner => inner.Value()
                                    .ChangedType <SampleDescendant1>(inner2 => inner2.Class()
                                                                     .Replaced(x => x.Value, "b", "c")
                                                                     )
                                    )
                           .MakeDiff();

            var ret = Merger.Instance.Partial.Diff(@base, changed);

            Assert.AreEqual(expected, ret);
        }
Example #21
0
        public void TestClassReplaced()
        {
            var @base = new Sample
            {
                ValueInner = new SampleInner
                {
                    Id    = 1,
                    Value = "one"
                }
            };
            var changed = new Sample
            {
                ValueInner = new SampleInner
                {
                    Id    = 1,
                    Value = "two"
                }
            };

            var expected = DiffFactory.Create <Sample>().Class()
                           .Replaced(x => x.ValueInner, new SampleInner {
                Id = 1, Value = "one"
            }, new SampleInner {
                Id = 1, Value = "two"
            })
                           .MakeDiff();

            var ret = Merger.Instance.Partial.Diff(@base, changed);

            Assert.AreEqual(expected, ret);
        }
Example #22
0
        public void OneAdded()
        {
            var diff = DiffFactory.Create <SampleBase[]>().Ordered()
                       .Added(1, new SampleDescendant1 {
                Id = 2, Value = "b"
            })
                       .MakeDiff();

            var obj = new SampleBase[]
            {
                new SampleDescendant1 {
                    Id = 1, Value = "a"
                }
            };
            var changed = new SampleBase[]
            {
                new SampleDescendant1 {
                    Id = 1, Value = "a"
                },
                new SampleDescendant1 {
                    Id = 2, Value = "b"
                }
            };

            var ret = Merger.Instance.Partial.ApplyPatch(obj, diff);

            CollectionAssert.AreEqual(changed, ret);
        }
        public void UnchangedNonEmpty()
        {
            var @base = new Dictionary <string, Sample>
            {
                { "a", new Sample {
                      Id = 1, Value = "a"
                  } },
                { "b", new Sample {
                      Id = 2, Value = "b"
                  } }
            };
            var changed = new Dictionary <string, Sample>
            {
                { "a", new Sample {
                      Id = 1, Value = "a"
                  } },
                { "b", new Sample {
                      Id = 2, Value = "b"
                  } }
            };

            var expected = DiffFactory.Create <Dictionary <string, Sample> >().KeyValue()
                           .MakeDiff();

            var ret = Merger.Instance.Partial.Diff(@base, changed);

            Assert.AreEqual(expected, ret);
        }
Example #24
0
        public void OneChangedProperty()
        {
            var diff = DiffFactory.Create <SampleBase[]>().Ordered()
                       .Changed(1, inner => inner.Value()
                                .ChangedType <SampleDescendant1>(inner2 => inner2.Class()
                                                                 .Replaced(x => x.Value, "b", "c")
                                                                 )
                                )
                       .MakeDiff();

            var obj = new SampleBase[]
            {
                new SampleDescendant1 {
                    Id = 1, Value = "a"
                },
                new SampleDescendant1 {
                    Id = 2, Value = "b"
                }
            };
            var changed = new SampleBase[]
            {
                new SampleDescendant1 {
                    Id = 1, Value = "a"
                },
                new SampleDescendant1 {
                    Id = 2, Value = "c"
                }
            };

            var ret = Merger.Instance.Partial.ApplyPatch(obj, diff);

            CollectionAssert.AreEqual(changed, ret);
        }
Example #25
0
        public void RemovedAndReplacedPlusNonConflicted()
        {
            var left = DiffFactory.Create <int[]>().Ordered()
                       .Removed(3, 3)
                       .Removed(4, 4)
                       .Added(5, 4)
                       .MakeDiff();
            var right = DiffFactory.Create <int[]>().Ordered()
                        .Replaced(3, 3, 4)
                        .MakeDiff();

            IConflictContainer conflicts;
            var result = Merger.Instance.Partial.MergeDiffs(left, right, out conflicts);

            var merged = DiffFactory.Create <int[]>().Ordered()
                         .Conflicted(
                c => c.Removed(3, 3),
                c => c.Replaced(3, 3, 4)
                )
                         .Removed(4, 4)
                         .Added(5, 4)
                         .MakeDiff();

            Assert.AreEqual(merged, result);
            Assert.IsTrue(conflicts.HasConflicts);
        }
Example #26
0
        public void OneRemoved()
        {
            var diff = DiffFactory.Create <Dictionary <string, Sample> >().KeyValue()
                       .Removed("c", new Sample {
                Id = 3, Value = "c"
            })
                       .MakeDiff();

            var obj = new Dictionary <string, Sample>
            {
                { "a", new Sample {
                      Id = 1, Value = "a"
                  } },
                { "b", new Sample {
                      Id = 2, Value = "b"
                  } },
                { "c", new Sample {
                      Id = 3, Value = "c"
                  } }
            };
            var changed = new Dictionary <string, Sample>
            {
                { "a", new Sample {
                      Id = 1, Value = "a"
                  } },
                { "b", new Sample {
                      Id = 2, Value = "b"
                  } }
            };

            var ret = Merger.Instance.Partial.ApplyPatch(obj, diff);

            CollectionAssert.AreEqual(changed, ret);
        }
Example #27
0
        public void OneAdded()
        {
            var @base = new[]
            {
                new SampleDescendant1 {
                    Id = 1, Value = "a"
                },
                new SampleDescendant1 {
                    Id = 3, Value = "c"
                }
            };
            var changed = new[]
            {
                new SampleDescendant1 {
                    Id = 1, Value = "a"
                },
                new SampleDescendant1 {
                    Id = 2, Value = "b"
                },
                new SampleDescendant1 {
                    Id = 3, Value = "c"
                }
            };

            var expected = DiffFactory.Create <SampleDescendant1[]>().Ordered()
                           .Added(1, new SampleDescendant1 {
                Id = 2, Value = "b"
            })
                           .MakeDiff();

            var ret = Merger.Instance.Partial.Diff(@base, changed);

            Assert.AreEqual(expected, ret);
        }
Example #28
0
        public void OneRemoved()
        {
            var diff = DiffFactory.Create <Sample[]>().Ordered()
                       .Removed(2, new Sample {
                Id = 3, Value = "c"
            })
                       .MakeDiff();

            var obj = new[]
            {
                new Sample {
                    Id = 1, Value = "a"
                },
                new Sample {
                    Id = 2, Value = "b"
                },
                new Sample {
                    Id = 3, Value = "c"
                }
            };
            var changed = new[]
            {
                new Sample {
                    Id = 1, Value = "a"
                },
                new Sample {
                    Id = 2, Value = "b"
                }
            };

            var ret = Merger.Instance.Partial.ApplyPatch(obj, diff);

            CollectionAssert.AreEqual(changed, ret);
        }
Example #29
0
        public void ChangedRemoved()
        {
            var left = DiffFactory.Create <HashSet <Sample> >().Unordered()
                       .Changed(1, inner => inner.Class()
                                .Replaced(x => x.Value, "a", "b")
                                )
                       .MakeDiff();
            var right = DiffFactory.Create <HashSet <Sample> >().Unordered()
                        .Removed(new Sample {
                Id = 1, Value = "a"
            })
                        .MakeDiff();

            IConflictContainer conflicts;
            var result = Merger.Instance.Partial.MergeDiffs(left, right, out conflicts);

            var merged = DiffFactory.Create <HashSet <Sample> >().Unordered()
                         .Conflicted(
                c => c.Changed(1, inner => inner.Class()
                               .Replaced(x => x.Value, "a", "b")
                               ),
                c => c.Removed(new Sample {
                Id = 1, Value = "a"
            })
                )
                         .MakeDiff();

            Assert.AreEqual(merged, result);
            Assert.IsTrue(conflicts.HasConflicts);
        }
Example #30
0
        public void TestUnifiedDiffParsing_AddedRemoved()
        {
            string inputA =
                "This is a test file!\n" +
                "Added another line to test file\n" +
                "Adding a third line to test file";

            string inputB =
                "This is a test file!\n" +
                "Adding a third line to test file\n" +
                "Adding a fourth line to test file";

            List <Diff.Diff> diff      = DiffFactory.GenerateDiffCache(inputA, inputB);
            DiffTextModel    textModel = DiffFactory.GenerateUnifiedDiff(diff);

            Assert.IsTrue(textModel.LineCount == 5);

            DiffTextLine removedLine = textModel.GetLine(1) as DiffTextLine;

            Assert.IsTrue(removedLine.ToString() == "Added another line to test file");
            Assert.IsTrue(removedLine.BeforeLineNo == 2);
            Assert.IsTrue(removedLine.ChangeType == DiffLineType.Remove);

            DiffTextLine addedLine = textModel.GetLine(3) as DiffTextLine;

            Assert.IsTrue(addedLine.ToString() == "Adding a third line to test file");
            Assert.IsTrue(addedLine.BeforeLineNo == -1);
            Assert.IsTrue(addedLine.LineNo == 2);
            Assert.IsTrue(addedLine.ChangeType == DiffLineType.Insert);
        }