public void ClearBothWhenDirty() { var x = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var y = new WithObservableCollectionProperties(new ComplexType("c", 2), new ComplexType("d", 4), new ComplexType("e", 5)); var changes = new List <string>(); var expectedChanges = new List <string>(); using (var tracker = Track.IsDirty(x, y, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(true, tracker.IsDirty); var expected = "WithObservableCollectionProperties Complexes [0] Name x: a y: c Value x: 1 y: 2 [1] Name x: b y: d Value x: 2 y: 4 [2] x: missing item y: Gu.State.Tests.DirtyTrackerTypes+ComplexType"; var actual = tracker.Diff.ToString(string.Empty, " "); CollectionAssert.AreEqual(expected, actual); CollectionAssert.IsEmpty(changes); x.Complexes.Clear(); Assert.AreEqual(true, tracker.IsDirty); expected = "WithObservableCollectionProperties Complexes [0] x: missing item y: Gu.State.Tests.DirtyTrackerTypes+ComplexType [1] x: missing item y: Gu.State.Tests.DirtyTrackerTypes+ComplexType [2] x: missing item y: Gu.State.Tests.DirtyTrackerTypes+ComplexType"; actual = tracker.Diff.ToString(string.Empty, " "); Assert.AreEqual(expected, actual); expectedChanges.AddRange(new[] { "Diff" }); CollectionAssert.AreEqual(expectedChanges, changes); y.Complexes.Clear(); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); } }
public void MoveX() { var x = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var y = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var changes = new List <string>(); var expectedChanges = new List <string>(); using (var tracker = Track.IsDirty(x, y, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); CollectionAssert.IsEmpty(changes); x.Complexes.Move(0, 1); Assert.AreEqual(true, tracker.IsDirty); var expected = "WithObservableCollectionProperties Complexes [0] Name x: b y: a Value x: 2 y: 1 [1] Name x: a y: b Value x: 1 y: 2"; var actual = tracker.Diff.ToString("", " "); Assert.AreEqual(expected, actual); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); x.Complexes.Move(0, 1); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); } }
public void Replace() { var x = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var y = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var changes = new List <string>(); var expectedChanges = new List <string>(); using (var tracker = Track.IsDirty(x, y, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); CollectionAssert.IsEmpty(changes); x.Complexes[0] = new ComplexType("c", 3); Assert.AreEqual(true, tracker.IsDirty); Assert.AreEqual("WithObservableCollectionProperties Complexes [0] Name x: c y: a Value x: 3 y: 1", tracker.Diff.ToString(string.Empty, " ")); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); y.Complexes[0] = new ComplexType("c", 3); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); } }
public void TracksItems() { var x = new WithObservableCollectionProperties(); var y = new WithObservableCollectionProperties(); var changes = new List <string>(); var expectedChanges = new List <string>(); using (var tracker = Track.IsDirty(x, y, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); CollectionAssert.IsEmpty(changes); x.Complexes.Add(new ComplexType("a", 1)); Assert.AreEqual(true, tracker.IsDirty); Assert.AreEqual("WithObservableCollectionProperties Complexes [0] x: Gu.State.Tests.DirtyTrackerTypes+ComplexType y: missing item", tracker.Diff.ToString(string.Empty, " ")); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); y.Complexes.Add(new ComplexType("a", 1)); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); x.Complexes[0].Value++; Assert.AreEqual(true, tracker.IsDirty); Assert.AreEqual("WithObservableCollectionProperties Complexes [0] Value x: 2 y: 1", tracker.Diff.ToString(string.Empty, " ")); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); y.Complexes[0].Value++; Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); var complexType = y.Complexes[0]; y.Complexes[0] = new ComplexType(complexType.Name, complexType.Value); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); CollectionAssert.AreEqual(expectedChanges, changes); complexType.Value++; Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); CollectionAssert.AreEqual(expectedChanges, changes); } }
//[TestCase(ReferenceHandling.Reference)] public void Remove(ReferenceHandling referenceHandling) { var source = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var target = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); using (Synchronize.PropertyValues(source, target, referenceHandling)) { source.Complexes.RemoveAt(1); var expected = new[] { new ComplexType("a", 1) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); source.Complexes.RemoveAt(0); CollectionAssert.IsEmpty(source.Complexes); CollectionAssert.IsEmpty(target.Complexes); } }
//[TestCase(ReferenceHandling.Reference)] public void Remove(ReferenceHandling referenceHandling) { var source = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var target = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); using (Synchronize.PropertyValues(source, target, referenceHandling)) { source.Complexes.RemoveAt(1); var expected = new[] { new ComplexType("a", 1) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); source.Complexes.RemoveAt(0); CollectionAssert.IsEmpty(source.Complexes); CollectionAssert.IsEmpty(target.Complexes); } }
//[TestCase(ReferenceHandling.Reference)] public void Add(ReferenceHandling referenceHandling) { var source = new WithObservableCollectionProperties(); var target = new WithObservableCollectionProperties(); using (Synchronize.PropertyValues(source, target, referenceHandling)) { source.Complexes.Add(new ComplexType("a", 1)); var expected = new[] { new ComplexType("a", 1) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); source.Complexes[0].Value++; expected = new[] { new ComplexType("a", 2) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); } }
//[TestCase(ReferenceHandling.Reference)] public void Replace(ReferenceHandling referenceHandling) { var source = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var target = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); using (Synchronize.PropertyValues(source, target, referenceHandling)) { source.Complexes[0] = new ComplexType("c", 3); var expected = new[] { new ComplexType("c", 3), new ComplexType("b", 2) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); source.Complexes[1] = new ComplexType("d", 4); expected = new[] { new ComplexType("c", 3), new ComplexType("d", 4) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); } }
//[TestCase(ReferenceHandling.Reference)] public void Add(ReferenceHandling referenceHandling) { var source = new WithObservableCollectionProperties(); var target = new WithObservableCollectionProperties(); using (Synchronize.PropertyValues(source, target, referenceHandling)) { source.Complexes.Add(new ComplexType("a", 1)); var expected = new[] { new ComplexType("a", 1) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); source.Complexes[0].Value++; expected = new[] { new ComplexType("a", 2) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); } }
public void Synchronizes() { var source = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var target = new WithObservableCollectionProperties(); using (Synchronize.PropertyValues(source, target, ReferenceHandling.Structural)) { var expected = new List <ComplexType> { new ComplexType("a", 1), new ComplexType("b", 2) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); Assert.AreNotSame(source.Complexes[0], target.Complexes[0]); Assert.AreNotSame(source.Complexes[1], target.Complexes[1]); source.Complexes.Add(new ComplexType("c", 3)); expected.Add(new ComplexType("c", 3)); CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); Assert.AreNotSame(source.Complexes[0], target.Complexes[0]); Assert.AreNotSame(source.Complexes[1], target.Complexes[1]); Assert.AreNotSame(source.Complexes[2], target.Complexes[2]); source.Complexes[2].Name = "changed"; expected[2].Name = "changed"; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); Assert.AreNotSame(source.Complexes[0], target.Complexes[0]); Assert.AreNotSame(source.Complexes[1], target.Complexes[1]); Assert.AreNotSame(source.Complexes[2], target.Complexes[2]); source.Complexes.RemoveAt(1); expected.RemoveAt(1); CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); Assert.AreNotSame(source.Complexes[0], target.Complexes[0]); Assert.AreNotSame(source.Complexes[1], target.Complexes[1]); source.Complexes.Clear(); Assert.AreEqual(0, source.Complexes.Count); Assert.AreEqual(0, target.Complexes.Count); } }
public void RemoveTheDifference() { var x = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var y = new WithObservableCollectionProperties(new ComplexType("a", 1)); var changes = new List <string>(); var expectedChanges = new List <string>(); using (var tracker = Track.IsDirty(x, y, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(true, tracker.IsDirty); Assert.AreEqual("WithObservableCollectionProperties Complexes [1] x: Gu.State.Tests.DirtyTrackerTypes+ComplexType y: missing item", tracker.Diff.ToString(string.Empty, " ")); CollectionAssert.IsEmpty(changes); x.Complexes.RemoveAt(1); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); } }
public void CreateAndDisposeStructural() { var source = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var target = new WithObservableCollectionProperties(); using (Synchronize.PropertyValues(source, target, ReferenceHandling.Structural)) { var expected = new[] { new ComplexType("a", 1), new ComplexType("b", 2) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); source.Complexes[0].Value++; expected = new[] { new ComplexType("a", 2), new ComplexType("b", 2) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); Assert.AreNotSame(source.Complexes[0], target.Complexes[0]); Assert.AreNotSame(source.Complexes[1], target.Complexes[1]); } source.Complexes.Add(new ComplexType("c", 3)); CollectionAssert.AreEqual( new[] { new ComplexType("a", 2), new ComplexType("b", 2), new ComplexType("c", 3) }, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual( new[] { new ComplexType("a", 2), new ComplexType("b", 2) }, target.Complexes, ComplexType.Comparer); source.Complexes[0].Value++; CollectionAssert.AreEqual( new[] { new ComplexType("a", 3), new ComplexType("b", 2), new ComplexType("c", 3) }, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual( new[] { new ComplexType("a", 2), new ComplexType("b", 2) }, target.Complexes, ComplexType.Comparer); }
public void AddSameToBoth() { var x = new WithObservableCollectionProperties(); var y = new WithObservableCollectionProperties(); var changes = new List<string>(); var expectedChanges = new List<string>(); using (var tracker = Track.IsDirty(x, y, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); CollectionAssert.IsEmpty(changes); x.Complexes.Add(new ComplexType("a", 1)); Assert.AreEqual(true, tracker.IsDirty); Assert.AreEqual("WithObservableCollectionProperties Complexes [0] x: Gu.State.Tests.DirtyTrackerTypes+ComplexType y: missing item", tracker.Diff.ToString("", " ")); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); y.Complexes.Add(new ComplexType("a", 1)); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); x.Complexes[0].Value++; Assert.AreEqual(true, tracker.IsDirty); Assert.AreEqual("WithObservableCollectionProperties Complexes [0] Value x: 2 y: 1", tracker.Diff.ToString("", " ")); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); y.Complexes[0].Value++; Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); } }
public void CreateAndDisposeStructural() { var source = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var target = new WithObservableCollectionProperties(); using (Synchronize.PropertyValues(source, target, ReferenceHandling.Structural)) { var expected = new[] { new ComplexType("a", 1), new ComplexType("b", 2) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); source.Complexes[0].Value++; expected = new[] { new ComplexType("a", 2), new ComplexType("b", 2) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); Assert.AreNotSame(source.Complexes[0], target.Complexes[0]); Assert.AreNotSame(source.Complexes[1], target.Complexes[1]); } source.Complexes.Add(new ComplexType("c", 3)); CollectionAssert.AreEqual( new[] { new ComplexType("a", 2), new ComplexType("b", 2), new ComplexType("c", 3) }, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual( new[] { new ComplexType("a", 2), new ComplexType("b", 2) }, target.Complexes, ComplexType.Comparer); source.Complexes[0].Value++; CollectionAssert.AreEqual( new[] { new ComplexType("a", 3), new ComplexType("b", 2), new ComplexType("c", 3) }, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual( new[] { new ComplexType("a", 2), new ComplexType("b", 2) }, target.Complexes, ComplexType.Comparer); }
public void RemoveStillDirty() { var x = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var y = new WithObservableCollectionProperties(new ComplexType("c", 3)); var changes = new List <string>(); var expectedChanges = new List <string>(); using (var tracker = Track.IsDirty(x, y, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(true, tracker.IsDirty); var expected = "WithObservableCollectionProperties Complexes [0] Name x: a y: c Value x: 1 y: 3 [1] x: Gu.State.Tests.DirtyTrackerTypes+ComplexType y: missing item"; var actual = tracker.Diff.ToString("", " "); CollectionAssert.AreEqual(expected, actual); CollectionAssert.IsEmpty(changes); x.Complexes.RemoveAt(1); Assert.AreEqual(true, tracker.IsDirty); Assert.AreEqual("WithObservableCollectionProperties Complexes [0] Name x: a y: c Value x: 1 y: 3", tracker.Diff.ToString("", " ")); expectedChanges.AddRange(new[] { "Diff" }); CollectionAssert.AreEqual(expectedChanges, changes); } }
public void Synchronizes() { var source = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var target = new WithObservableCollectionProperties(); using (Synchronize.PropertyValues(source, target, ReferenceHandling.Structural)) { var expected = new List<ComplexType> { new ComplexType("a", 1), new ComplexType("b", 2) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); Assert.AreNotSame(source.Complexes[0], target.Complexes[0]); Assert.AreNotSame(source.Complexes[1], target.Complexes[1]); source.Complexes.Add(new ComplexType("c", 3)); expected.Add(new ComplexType("c", 3)); CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); Assert.AreNotSame(source.Complexes[0], target.Complexes[0]); Assert.AreNotSame(source.Complexes[1], target.Complexes[1]); Assert.AreNotSame(source.Complexes[2], target.Complexes[2]); source.Complexes[2].Name = "changed"; expected[2].Name = "changed"; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); Assert.AreNotSame(source.Complexes[0], target.Complexes[0]); Assert.AreNotSame(source.Complexes[1], target.Complexes[1]); Assert.AreNotSame(source.Complexes[2], target.Complexes[2]); source.Complexes.RemoveAt(1); expected.RemoveAt(1); CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); Assert.AreNotSame(source.Complexes[0], target.Complexes[0]); Assert.AreNotSame(source.Complexes[1], target.Complexes[1]); source.Complexes.Clear(); Assert.AreEqual(0, source.Complexes.Count); Assert.AreEqual(0, target.Complexes.Count); } }
//[TestCase(ReferenceHandling.Reference)] public void Replace(ReferenceHandling referenceHandling) { var source = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var target = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); using (Synchronize.PropertyValues(source, target, referenceHandling)) { source.Complexes[0] = new ComplexType("c", 3); var expected = new[] { new ComplexType("c", 3), new ComplexType("b", 2) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); source.Complexes[1] = new ComplexType("d", 4); expected = new[] { new ComplexType("c", 3), new ComplexType("d", 4) }; CollectionAssert.AreEqual(expected, source.Complexes, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target.Complexes, ComplexType.Comparer); } }
public void Replace() { var x = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var y = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var changes = new List<string>(); var expectedChanges = new List<string>(); using (var tracker = Track.IsDirty(x, y, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); CollectionAssert.IsEmpty(changes); x.Complexes[0] = new ComplexType("c", 3); Assert.AreEqual(true, tracker.IsDirty); Assert.AreEqual("WithObservableCollectionProperties Complexes [0] Name x: c y: a Value x: 3 y: 1", tracker.Diff.ToString("", " ")); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); y.Complexes[0] = new ComplexType("c", 3); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); } }
public void ClearBothWhenDirty() { var x = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var y = new WithObservableCollectionProperties(new ComplexType("c", 2), new ComplexType("d", 4), new ComplexType("e", 5)); var changes = new List<string>(); var expectedChanges = new List<string>(); using (var tracker = Track.IsDirty(x, y, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(true, tracker.IsDirty); var expected = "WithObservableCollectionProperties Complexes [0] Name x: a y: c Value x: 1 y: 2 [1] Name x: b y: d Value x: 2 y: 4 [2] x: missing item y: Gu.State.Tests.DirtyTrackerTypes+ComplexType"; var actual = tracker.Diff.ToString("", " "); CollectionAssert.AreEqual(expected, actual); CollectionAssert.IsEmpty(changes); x.Complexes.Clear(); Assert.AreEqual(true, tracker.IsDirty); expected = "WithObservableCollectionProperties Complexes [0] x: missing item y: Gu.State.Tests.DirtyTrackerTypes+ComplexType [1] x: missing item y: Gu.State.Tests.DirtyTrackerTypes+ComplexType [2] x: missing item y: Gu.State.Tests.DirtyTrackerTypes+ComplexType"; actual = tracker.Diff.ToString("", " "); Assert.AreEqual(expected, actual); expectedChanges.AddRange(new[] { "Diff" }); CollectionAssert.AreEqual(expectedChanges, changes); y.Complexes.Clear(); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); } }
public void RemoveStillDirty() { var x = new WithObservableCollectionProperties(new ComplexType("a", 1), new ComplexType("b", 2)); var y = new WithObservableCollectionProperties(new ComplexType("c", 3)); var changes = new List<string>(); var expectedChanges = new List<string>(); using (var tracker = Track.IsDirty(x, y, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(true, tracker.IsDirty); var expected = "WithObservableCollectionProperties Complexes [0] Name x: a y: c Value x: 1 y: 3 [1] x: Gu.State.Tests.DirtyTrackerTypes+ComplexType y: missing item"; var actual = tracker.Diff.ToString("", " "); CollectionAssert.AreEqual(expected, actual); CollectionAssert.IsEmpty(changes); x.Complexes.RemoveAt(1); Assert.AreEqual(true, tracker.IsDirty); Assert.AreEqual("WithObservableCollectionProperties Complexes [0] Name x: a y: c Value x: 1 y: 3", tracker.Diff.ToString("", " ")); expectedChanges.AddRange(new[] { "Diff" }); CollectionAssert.AreEqual(expectedChanges, changes); } }