public void CreateAndDisposeExplicitSetting(ReferenceHandling referenceHandling) { var source = new WithSimpleProperties { Value1 = 1, Time = DateTime.MinValue }; var propertyChanges = new List <string>(); var expectedPropertyChanges = new List <string>(); var changes = new List <EventArgs>(); using (var tracker = Track.Changes(source, referenceHandling)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); source.Value1++; Assert.AreEqual(1, tracker.Changes); expectedPropertyChanges.AddRange(new[] { "Changes" }); CollectionAssert.AreEqual(expectedPropertyChanges, propertyChanges); var expected = new[] { RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(source, tracker.Settings, isRoot: false).Value, new PropertyChangeEventArgs(source, source.GetProperty(nameof(source.Value1)))) }; CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); } source.Value1++; CollectionAssert.AreEqual(expectedPropertyChanges, propertyChanges); #if !DEBUG // debug build keeps instances alive longer for nicer debugging experience var wrx = new System.WeakReference(source); source = null; System.GC.Collect(); Assert.AreEqual(false, wrx.IsAlive); #endif }
public void Remove() { var source = new With <ObservableCollection <ComplexType> > { Value = new ObservableCollection <ComplexType> { new ComplexType(), null } }; var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); var expectedChanges = new List <EventArgs>(); using (var tracker = Track.Changes(source, ReferenceHandling.Structural)) { var sourceNode = ChangeTrackerNode.GetOrCreate(source, tracker.Settings, false) .Value; tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); source.Value.RemoveAt(1); Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); expectedChanges.Add( new PropertyGraphChangedEventArgs <ChangeTrackerNode>( sourceNode, source.GetProperty("Value"), RootChangeEventArgs.Create( ChangeTrackerNode.GetOrCreate( (INotifyCollectionChanged)source.Value, tracker.Settings, false) .Value, new RemoveEventArgs(source.Value, 1)))); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); var complexType = source.Value[0]; source.Value.RemoveAt(0); Assert.AreEqual(2, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes" }, propertyChanges); expectedChanges.Add( new PropertyGraphChangedEventArgs <ChangeTrackerNode>( sourceNode, source.GetProperty("Value"), RootChangeEventArgs.Create( ChangeTrackerNode.GetOrCreate( (INotifyCollectionChanged)source.Value, tracker.Settings, false) .Value, new RemoveEventArgs(source.Value, 0)))); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); complexType.Value++; Assert.AreEqual(2, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes" }, propertyChanges); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); } }
public void Remove(ReferenceHandling referenceHandling) { var source = new ObservableCollection <int> { 1, 2 }; var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); using (var tracker = Track.Changes(source, referenceHandling)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); source.RemoveAt(1); Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); var node = ChangeTrackerNode.GetOrCreate((INotifyCollectionChanged)source, tracker.Settings, isRoot: false).Value; var expected = new[] { RootChangeEventArgs.Create(node, new RemoveEventArgs(source, 1)) }; CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); source.RemoveAt(0); Assert.AreEqual(2, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes" }, propertyChanges); expected = new[] { RootChangeEventArgs.Create(node, new RemoveEventArgs(source, 1)), RootChangeEventArgs.Create(node, new RemoveEventArgs(source, 0)) }; CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); } }
public void StopsSubscribing() { var source = new With <ComplexType> { Value = new ComplexType() }; var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); using (var tracker = Track.Changes(source, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); var oldValue = source.Value; source.Value = null; Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); var expected = new[] { RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(source, tracker.Settings, false).Value, new PropertyChangeEventArgs(source, source.GetProperty(nameof(source.Value)))) }; CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); oldValue.Value++; Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); } }
public void StartsSubscribingOneLevel() { var source = new Level(); var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); var expectedChanges = new List <EventArgs>(); using (var tracker = Track.Changes(source, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); source.Next = new Level(); Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); var sourceNode = ChangeTrackerNode.GetOrCreate(source, tracker.Settings, isRoot: false).Value; expectedChanges.Add(RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(source, tracker.Settings, isRoot: false).Value, new PropertyChangeEventArgs(source, source.GetProperty("Next")))); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); source.Next.Value++; Assert.AreEqual(2, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes" }, propertyChanges); expectedChanges.Add(new PropertyGraphChangedEventArgs <ChangeTrackerNode>(sourceNode, source.GetProperty("Next"), RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(source.Next, tracker.Settings, isRoot: false).Value, new PropertyChangeEventArgs(source.Next, source.Next.GetProperty("Value"))))); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); } }
public void Add() { var source = new ObservableCollection <ComplexType>(); var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); using (var tracker = Track.Changes(source, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); source.Add(new ComplexType()); Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); var node = ChangeTrackerNode.GetOrCreate((INotifyCollectionChanged)source, tracker.Settings, false).Value; var expected = new[] { RootChangeEventArgs.Create(node, new AddEventArgs(source, 0)) }; CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); source.Add(new ComplexType()); Assert.AreEqual(2, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes" }, propertyChanges); expected = new[] { RootChangeEventArgs.Create(node, new AddEventArgs(source, 0)), RootChangeEventArgs.Create(node, new AddEventArgs(source, 1)) }; CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); } }
public void IgnoresBaseClassPropertyLambda() { var source = new DerivedClass(); var settings = PropertiesSettings.Build() .IgnoreProperty <ComplexType>(x => x.Excluded) .CreateSettings(ReferenceHandling.Structural); var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); using (var tracker = Track.Changes(source, settings)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); source.Value++; Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); var expected = new[] { RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(source, tracker.Settings, isRoot: false).Value, new PropertyChangeEventArgs(source, source.GetProperty(nameof(source.Value)))) }; CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); source.Excluded++; Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); } }
public void IgnoresProperty() { var withIllegalObject = new WithIllegal(); var propertyInfo = typeof(WithIllegal).GetProperty(nameof(WithIllegal.Illegal)); var settings = new PropertiesSettingsBuilder().IgnoreProperty(propertyInfo) .CreateSettings(ReferenceHandling.Structural); var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); using (var tracker = Track.Changes(withIllegalObject, settings)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); withIllegalObject.Value++; Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); var expected = new[] { RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(withIllegalObject, tracker.Settings, isRoot: false).Value, new PropertyChangeEventArgs(withIllegalObject, withIllegalObject.GetType().GetProperty(nameof(withIllegalObject.Value)))) }; CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); withIllegalObject.Illegal = new IllegalType(); Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); } }
public void SameItemTwiceNotifies() { var item = new ComplexType(); var source = new ObservableCollection <ComplexType> { item, item }; var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); using (var tracker = Track.Changes(source, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); item.Value++; Assert.AreEqual(2, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes" }, propertyChanges); var sourceNode = ChangeTrackerNode.GetOrCreate((INotifyCollectionChanged)source, tracker.Settings, false) .Value; var expected = new[] { new ItemGraphChangedEventArgs <ChangeTrackerNode>(sourceNode, 0, RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(source[0], tracker.Settings, false).Value, new PropertyChangeEventArgs(source[0], source[0].GetProperty("Value")))), new ItemGraphChangedEventArgs <ChangeTrackerNode>(sourceNode, 1, RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(source[1], tracker.Settings, false).Value, new PropertyChangeEventArgs(source[1], source[1].GetProperty("Value")))) }; CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); } }
public void ChildNameChanges() { var parent = new Parent { Child = new Child(string.Empty) }; parent.Child.Parent = parent; var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); using (var tracker = Track.Changes(parent, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(changes); parent.Child.Name += "abc"; Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); var rootChangeEventArgs = RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(parent.Child, tracker.Settings, isRoot: false).Value, new PropertyChangeEventArgs(parent.Child, parent.Child.GetProperty(nameof(Child.Name)))); var expected = new[] { new PropertyGraphChangedEventArgs <ChangeTrackerNode>(ChangeTrackerNode.GetOrCreate(parent, tracker.Settings, isRoot: false).Value, parent.GetType().GetProperty("Child"), rootChangeEventArgs) }; CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); } }
public void WithSelf() { var source = new WithSelf(); var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); var expectedChanges = new List <EventArgs>(); using (var tracker = Track.Changes(source, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); source.Value = source; Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); expectedChanges.Add(RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(source, tracker.Settings, isRoot: false).Value, new PropertyChangeEventArgs(source, source.GetProperty(nameof(source.Value))))); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); source.Name += "abc"; Assert.AreEqual(2, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes" }, propertyChanges); expectedChanges.Add(RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(source, tracker.Settings, isRoot: false).Value, new PropertyChangeEventArgs(source, source.GetProperty(nameof(source.Name))))); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); } }
public void ReplaceStartsListeningToNew() { var source = new ObservableCollection <ComplexType> { new ComplexType(), new ComplexType() }; var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); var expected = new List <EventArgs>(); using (var tracker = Track.Changes(source, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); source[0] = new ComplexType(); Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); var node = ChangeTrackerNode.GetOrCreate((INotifyCollectionChanged)source, tracker.Settings, isRoot: false).Value; expected.Add(RootChangeEventArgs.Create(node, new ReplaceEventArgs(source, 0))); CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); source[0].Value++; Assert.AreEqual(2, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes" }, propertyChanges); var sourceNode = ChangeTrackerNode.GetOrCreate((INotifyCollectionChanged)source, tracker.Settings, isRoot: false) .Value; expected.Add(new ItemGraphChangedEventArgs <ChangeTrackerNode>(sourceNode, 0, RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(source[0], tracker.Settings, isRoot: false).Value, new PropertyChangeEventArgs(source[0], source[0].GetProperty("Value"))))); CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); } }
public void TracksCollectionProperty() { var source = new Level { Next = new Level { Levels = new ObservableCollection <Level>(new[] { new Level(), }) } }; var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); var expectedChanges = new List <EventArgs>(); using (var tracker = Track.Changes(source, ReferenceHandling.Structural)) { var sourceNode = ChangeTrackerNode.GetOrCreate(source, tracker.Settings, false) .Value; tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); source.Next.Levels[0].Value++; Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); expectedChanges.Add( new PropertyGraphChangedEventArgs <ChangeTrackerNode>( sourceNode, source.GetProperty("Next"), new PropertyGraphChangedEventArgs <ChangeTrackerNode>( ChangeTrackerNode.GetOrCreate(source.Next, tracker.Settings, false) .Value, source.GetProperty("Levels"), new ItemGraphChangedEventArgs <ChangeTrackerNode>( ChangeTrackerNode.GetOrCreate( (INotifyCollectionChanged)source.Next.Levels, tracker.Settings, false) .Value, 0, RootChangeEventArgs.Create( ChangeTrackerNode.GetOrCreate(source.Next.Levels[0], tracker.Settings, false) .Value, new PropertyChangeEventArgs(source.Next.Levels[0], source.Next.Levels[0].GetProperty("Value"))))))); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); } }
public void NotifiesOnAddSpecialCollection() { var source = new SpecialCollection(); var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); var expectedChanges = new List <EventArgs>(); using (var tracker = Track.Changes(source, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); var level = new Level(); source.Add(level); Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); var sourceNode = ChangeTrackerNode.GetOrCreate((INotifyCollectionChanged)source, tracker.Settings, isRoot: false).Value; expectedChanges.Add(RootChangeEventArgs.Create(sourceNode, new AddEventArgs(source, 0))); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); level.Value++; Assert.AreEqual(2, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes" }, propertyChanges); expectedChanges.Add( new ItemGraphChangedEventArgs <ChangeTrackerNode>( sourceNode, 0, new RootChangeEventArgs <ChangeTrackerNode>( ChangeTrackerNode.GetOrCreate(level, tracker.Settings, isRoot: false) .Value, new PropertyChangeEventArgs(level, level.GetProperty("Value"))))); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); source.Remove(level); Assert.AreEqual(3, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes", "Changes" }, propertyChanges); expectedChanges.Add(RootChangeEventArgs.Create(sourceNode, new RemoveEventArgs(source, 0))); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); level.Value++; Assert.AreEqual(3, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes", "Changes" }, propertyChanges); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); } }
public void SequenceOfChanges() { var parent = new Parent { Child = new Child("c") }; var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); var expected = new List <EventArgs>(); using (var tracker = Track.Changes(parent, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); parent.Name = "Poppa"; Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); var parentNode = ChangeTrackerNode.GetOrCreate(parent, tracker.Settings, isRoot: false).Value; expected.Add(RootChangeEventArgs.Create(parentNode, new PropertyChangeEventArgs(parent, parent.GetProperty("Name")))); CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); parent.Child = new Child("Child"); Assert.AreEqual(2, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes" }, propertyChanges); expected.Add(RootChangeEventArgs.Create(parentNode, new PropertyChangeEventArgs(parent, parent.GetProperty("Child")))); CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); parent.Child.Parent = parent; Assert.AreEqual(3, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes", "Changes" }, propertyChanges); expected.Add(new PropertyGraphChangedEventArgs <ChangeTrackerNode>(parentNode, parent.GetProperty("Child"), RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(parent.Child, tracker.Settings, isRoot: false).Value, new PropertyChangeEventArgs(parent.Child, parent.Child.GetProperty("Parent"))))); CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); parent.Name += "meh"; Assert.AreEqual(4, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes", "Changes", "Changes" }, propertyChanges); expected.Add(RootChangeEventArgs.Create(parentNode, new PropertyChangeEventArgs(parent, parent.GetProperty("Name")))); CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); } }
public void MoveThenItemsNotifies(int from, int to) { var source = new ObservableCollection <ComplexType> { new ComplexType(), new ComplexType(), new ComplexType() }; var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); var expectedChanges = new List <EventArgs>(); using (var tracker = Track.Changes(source, ReferenceHandling.Structural)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); Assert.AreEqual(0, tracker.Changes); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); source.Move(from, to); Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); var sourceNode = ChangeTrackerNode.GetOrCreate((INotifyCollectionChanged)source, tracker.Settings, false).Value; expectedChanges.Add(RootChangeEventArgs.Create(sourceNode, new MoveEventArgs(source, from, to))); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); source[0].Value++; Assert.AreEqual(2, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes" }, propertyChanges); expectedChanges.Add(new ItemGraphChangedEventArgs <ChangeTrackerNode>(sourceNode, 0, RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(source[0], tracker.Settings, false).Value, new PropertyChangeEventArgs(source[0], source[0].GetProperty("Value"))))); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); source[1].Value++; Assert.AreEqual(3, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes", "Changes" }, propertyChanges); expectedChanges.Add(new ItemGraphChangedEventArgs <ChangeTrackerNode>(sourceNode, 1, RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(source[1], tracker.Settings, false).Value, new PropertyChangeEventArgs(source[1], source[1].GetProperty("Value"))))); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); source[2].Value++; Assert.AreEqual(4, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes", "Changes", "Changes", "Changes" }, propertyChanges); expectedChanges.Add(new ItemGraphChangedEventArgs <ChangeTrackerNode>(sourceNode, 2, RootChangeEventArgs.Create(ChangeTrackerNode.GetOrCreate(source[2], tracker.Settings, false).Value, new PropertyChangeEventArgs(source[2], source[2].GetProperty("Value"))))); CollectionAssert.AreEqual(expectedChanges, changes, EventArgsComparer.Default); } }
public void WithImmutable(ReferenceHandling referenceHandling) { var source = new With <Immutable>(); var propertyChanges = new List <string>(); var changes = new List <EventArgs>(); using (var tracker = Track.Changes(source, referenceHandling)) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); tracker.Changed += (_, e) => changes.Add(e); CollectionAssert.IsEmpty(propertyChanges); CollectionAssert.IsEmpty(changes); source.Value = new Immutable(); Assert.AreEqual(1, tracker.Changes); CollectionAssert.AreEqual(new[] { "Changes" }, propertyChanges); var node = ChangeTrackerNode.GetOrCreate(source, tracker.Settings, isRoot: false).Value; var expected = new[] { RootChangeEventArgs.Create(node, new PropertyChangeEventArgs(source, source.GetProperty(nameof(source.Value)))) }; CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); } }