public void CreateAndDisposeExplicitSetting(ReferenceHandling referenceHandling) { var x = new WithSimpleProperties { Value = 1, Time = DateTime.MinValue }; var y = new WithSimpleProperties { Value = 1, Time = DateTime.MinValue }; var propertyChanges = new List<string>(); var expectedChanges = new List<string>(); using (var tracker = Track.IsDirty(x, y, PropertiesSettings.GetOrCreate(referenceHandling))) { tracker.PropertyChanged += (_, e) => propertyChanges.Add(e.PropertyName); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); CollectionAssert.IsEmpty(propertyChanges); x.Value++; Assert.AreEqual(true, tracker.IsDirty); Assert.AreEqual("WithSimpleProperties Value x: 2 y: 1", tracker.Diff.ToString("", " ")); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, propertyChanges); } x.Value++; CollectionAssert.AreEqual(expectedChanges, propertyChanges); #if (!DEBUG) // debug build keeps instances alive longer for nicer debugging experience var wrx = new System.WeakReference(x); var wry = new System.WeakReference(y); x = null; y = null; System.GC.Collect(); Assert.AreEqual(false, wrx.IsAlive); Assert.AreEqual(false, wry.IsAlive); #endif }
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, 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 HappyPath(ReferenceHandling referenceHandling) { var source = new WithSimpleProperties { IntValue = 1, NullableIntValue = 2, StringValue = "3", EnumValue = StringSplitOptions.RemoveEmptyEntries }; var target = new WithSimpleProperties { IntValue = 3, NullableIntValue = 4 }; using (Synchronize.PropertyValues(source, target, referenceHandling)) { Assert.AreEqual(1, source.IntValue); Assert.AreEqual(1, target.IntValue); Assert.AreEqual(2, source.NullableIntValue); Assert.AreEqual(2, target.NullableIntValue); Assert.AreEqual("3", source.StringValue); Assert.AreEqual("3", target.StringValue); Assert.AreEqual(StringSplitOptions.RemoveEmptyEntries, source.EnumValue); Assert.AreEqual(StringSplitOptions.RemoveEmptyEntries, target.EnumValue); source.IntValue = 5; Assert.AreEqual(5, source.IntValue); Assert.AreEqual(5, target.IntValue); } source.IntValue = 6; Assert.AreEqual(6, source.IntValue); Assert.AreEqual(5, target.IntValue); }
public void CreateAndDispose(ReferenceHandling referenceHandling) { var x = new ObservableCollection<ComplexType> { new ComplexType("a", 1), new ComplexType("b", 2) }; var y = new ObservableCollection<ComplexType>(); var changes = new List<string>(); using (var tracker = Track.IsDirty(x, y, referenceHandling)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(true, tracker.IsDirty); var expected = "ObservableCollection<ComplexType> [0] x: Gu.State.Tests.DirtyTrackerTypes+ComplexType y: missing item [1] x: Gu.State.Tests.DirtyTrackerTypes+ComplexType y: missing item"; var actual = tracker.Diff.ToString(""," "); Assert.AreEqual(expected, actual); CollectionAssert.IsEmpty(changes); } x.Add(new ComplexType("c", 3)); CollectionAssert.IsEmpty(changes); x[0].Value++; CollectionAssert.IsEmpty(changes); x[1].Value++; CollectionAssert.IsEmpty(changes); x[2].Value++; CollectionAssert.IsEmpty(changes); }
public void Excludes(ReferenceHandling referenceHandling) { var source = new WithSimpleProperties { IntValue = 1, StringValue = "2" }; var target = new WithSimpleProperties { IntValue = 3, StringValue = "4" }; var settings = PropertiesSettings.Build() .IgnoreProperty<WithSimpleProperties>(x => x.StringValue) .CreateSettings(referenceHandling); using (Synchronize.PropertyValues(source, target, settings)) { Assert.AreEqual(1, source.IntValue); Assert.AreEqual(1, target.IntValue); Assert.AreEqual("2", source.StringValue); Assert.AreEqual("4", target.StringValue); source.IntValue = 5; Assert.AreEqual(5, source.IntValue); Assert.AreEqual(5, target.IntValue); source.StringValue = "7"; Assert.AreEqual("7", source.StringValue); Assert.AreEqual("4", target.StringValue); } source.IntValue = 6; Assert.AreEqual(6, source.IntValue); Assert.AreEqual(5, target.IntValue); Assert.AreEqual("7", source.StringValue); Assert.AreEqual("4", target.StringValue); }
public void Add(ReferenceHandling referenceHandling) { var source = new ObservableCollection<int>(); 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.Add(1); 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(2); 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 Insert(ReferenceHandling referenceHandling) { var source = new ObservableCollection<int> { 1, 2 }; var target = new ObservableCollection<int> { 1, 2 }; using (Synchronize.PropertyValues(source, target, referenceHandling)) { source.Insert(1, 3); CollectionAssert.AreEqual(new[] { 1, 3, 2 }, source); CollectionAssert.AreEqual(new[] { 1, 3, 2 }, target); } }
public void ThrowsIfTargetCollectionChanges(ReferenceHandling referenceHandling) { var source = new ObservableCollection<int> { 1, 2 }; var target = new ObservableCollection<int> { 1, 2 }; using (Synchronize.PropertyValues(source, target, referenceHandling)) { var exception = Assert.Throws<InvalidOperationException>(() => target.Add(3)); var expected = "Target cannot be modified when a synchronizer is applied to it\r\n" + "The change would just trigger a dirty notification and the value would be updated with the value from source."; Assert.AreEqual(expected, exception.Message); } }
public void Add(ReferenceHandling referenceHandling) { var source = new ObservableCollection<WithGetReadOnlyPropertySealed<int>>(); var target = new ObservableCollection<WithGetReadOnlyPropertySealed<int>>(); using (Synchronize.PropertyValues(source, target, referenceHandling)) { source.Add(new WithGetReadOnlyPropertySealed<int>(1)); var expected = new[] { new WithGetReadOnlyPropertySealed<int>(1) }; CollectionAssert.AreEqual(expected, source); CollectionAssert.AreEqual(expected, target); Assert.AreSame(source[0], target[0]); } }
public void CreateAndDispose(ReferenceHandling referenceHandling) { var source = new ObservableCollection<int> { 1, 2 }; var target = new ObservableCollection<int>(); using (Synchronize.PropertyValues(source, target, referenceHandling)) { var expected = new[] { 1, 2 }; CollectionAssert.AreEqual(expected, source); CollectionAssert.AreEqual(expected, target); } source.Add(3); CollectionAssert.AreEqual(new[] { 1, 2, 3 }, source); CollectionAssert.AreEqual(new[] { 1, 2 }, target); }
public void Remove(ReferenceHandling referenceHandling) { var source = new ObservableCollection<int> { 1, 2 }; var target = new ObservableCollection<int> { 1, 2 }; using (Synchronize.PropertyValues(source, target, referenceHandling)) { source.RemoveAt(1); CollectionAssert.AreEqual(new[] { 1 }, source); CollectionAssert.AreEqual(new[] { 1 }, target); source.RemoveAt(0); CollectionAssert.IsEmpty(source); CollectionAssert.IsEmpty(target); } }
//[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); } }
public void Add(ReferenceHandling referenceHandling) { var source = new ObservableCollection<int>(); var target = new ObservableCollection<int>(); using (Synchronize.PropertyValues(source, target, referenceHandling)) { source.Add(1); CollectionAssert.AreEqual(new[] { 1 }, source); CollectionAssert.AreEqual(new[] { 1 }, target); } source.Add(2); CollectionAssert.AreEqual(new[] { 1, 2 }, source); CollectionAssert.AreEqual(new[] { 1 }, target); }
public void CreateAndDisposeWhenTargetIsEmpty(ReferenceHandling referenceHandling) { var source = new ObservableCollection<WithGetReadOnlyPropertySealed<int>> { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2) }; var target = new ObservableCollection<WithGetReadOnlyPropertySealed<int>>(); using (Synchronize.PropertyValues(source, target, referenceHandling)) { var expected = new[] { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2) }; CollectionAssert.AreEqual(expected, source); CollectionAssert.AreEqual(expected, target); Assert.AreSame(source[0], target[0]); Assert.AreSame(source[1], target[1]); } source.Add(new WithGetReadOnlyPropertySealed<int>(3)); CollectionAssert.AreEqual(new[] { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2), new WithGetReadOnlyPropertySealed<int>(3) }, source); CollectionAssert.AreEqual(new[] { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2) }, target); }
//[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 WithCalculated(ReferenceHandling referenceHandling) { var source = new WithCalculatedProperty { Value = 1 }; var target = new WithCalculatedProperty { Value = 3 }; using (Synchronize.PropertyValues(source, target, referenceHandling)) { Assert.AreEqual(1, source.Value); Assert.AreEqual(1, target.Value); source.Value = 5; Assert.AreEqual(5, source.Value); Assert.AreEqual(5, target.Value); } source.Value = 6; Assert.AreEqual(6, source.Value); Assert.AreEqual(5, target.Value); }
public void Tracks(ReferenceHandling referenceHandling) { var x = new WithImmutableProperty(); var y = new WithImmutableProperty(); var changes = new List<string>(); var expectedChanges = new List<string>(); using (var tracker = Track.IsDirty(x, y, referenceHandling)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); CollectionAssert.IsEmpty(changes); x.Name = "newName1"; Assert.AreEqual(true, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("WithImmutableProperty Name x: newName1 y: null", tracker.Diff.ToString("", " ")); y.Name = "newName1"; Assert.AreEqual(false, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual(null, tracker.Diff); x.ImmutableValue = new WithGetReadOnlyPropertySealed<int>(1); Assert.AreEqual(true, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("WithImmutableProperty ImmutableValue x: Gu.State.Tests.DirtyTrackerTypes+WithGetReadOnlyPropertySealed`1[System.Int32] y: null", tracker.Diff.ToString("", " ")); y.ImmutableValue = new WithGetReadOnlyPropertySealed<int>(1); Assert.AreEqual(false, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual(null, tracker.Diff); x.ImmutableValue = new WithGetReadOnlyPropertySealed<int>(2); Assert.AreEqual(true, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("WithImmutableProperty ImmutableValue x: Gu.State.Tests.DirtyTrackerTypes+WithGetReadOnlyPropertySealed`1[System.Int32] y: Gu.State.Tests.DirtyTrackerTypes+WithGetReadOnlyPropertySealed`1[System.Int32]", tracker.Diff.ToString("", " ")); } }
public void HandlesNull(ReferenceHandling referenceHandling) { var x = new WithComplexProperty(); var y = new WithComplexProperty(); var changes = new List<string>(); var expectedChanges = new List<string>(); using (var tracker = Track.IsDirty(x, y, referenceHandling)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); CollectionAssert.IsEmpty(changes); x.ComplexType = new ComplexType("a", 1); Assert.AreEqual(true, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); var expected = "WithComplexProperty ComplexType x: Gu.State.Tests.DirtyTrackerTypes+ComplexType y: null"; var actual = tracker.Diff.ToString("", " "); Assert.AreEqual(expected, actual); y.ComplexType = new ComplexType("a", 1); Assert.AreEqual(false, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual(null, tracker.Diff); x.ComplexType = null; Assert.AreEqual(true, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); expected = "WithComplexProperty ComplexType x: null y: Gu.State.Tests.DirtyTrackerTypes+ComplexType"; actual = tracker.Diff.ToString("", " "); Assert.AreEqual(expected, actual); y.ComplexType = null; Assert.AreEqual(false, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual(null, tracker.Diff); } }
public void LoadImages(ReferenceHandling refHandling = ReferenceHandling.Undefined) { ImageFileNames = new ObservableCollection<string>(); List<string> filesToRemove = new List<string>(); List<string> filesToAdd = new List<string>(); if(Directory.Exists(GalleryDirectory)){ IEnumerable<string> availableFiles = from path in Directory.GetFiles(GalleryDirectory) select Path.GetFileName(path); // Add files if they are located in the gallery folder and handle the others as specified foreach (string fileName in Model.ImageFileNames) { if (availableFiles.Contains(fileName)) { filesToAdd.Add(fileName); } else { if (refHandling == ReferenceHandling.Undefined) { // Let the user decide how to handle references to non-existing files ErrorMessage fileNotFound = new ErrorMessage("File Not Found Error", "File \"" + fileName + "\" not found. Do you want to proceed and remove all non-existent files from the gallery?", new Dictionary<string, UndoableCommand> { {"Yes", LoadValidImagesCommand}, {"Keep references", LoadAllFilesCommand}, {"Cancel", null} }); mediator.ShowMessage(fileNotFound); return; } else if (refHandling == ReferenceHandling.RemoveNonExisting) { // Do not add the file to the view model's collection and remove its reference from the model filesToRemove.Add(fileName); } else { // if(refHandling == ReferenceHandling.KeepNonExisting) // Add the file anyway and ignore that it does not exist filesToAdd.Add(fileName); } } } foreach (string file in filesToAdd) { ImageFileNames.Add(file); Console.WriteLine(file); } Model.ImageFileNames.RemoveAll(file => filesToRemove.Contains(file)); RaisePropertyChanged("ImageFileNames"); } }
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, false).Value; var expected = new[] { RootChangeEventArgs.Create(node, new PropertyChangeEventArgs(source, source.GetProperty(nameof(source.Value)))) }; CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default); } }
public void TracksNested(ReferenceHandling referenceHandling) { var x = new Level { Next = new Level { Next = new Level { Name = "a" } } }; var y = new Level { Next = new Level { Next = new Level { Name = "a" } } }; var changes = new List<string>(); var expectedChanges = new List<string>(); using (var tracker = Track.IsDirty(x, y, referenceHandling)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); CollectionAssert.IsEmpty(changes); x.Name = "newName1"; Assert.AreEqual(true, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("Level Name x: newName1 y: null", tracker.Diff.ToString("", " ")); y.Name = "newName1"; Assert.AreEqual(false, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual(null, tracker.Diff); x.Next.Next.Name = "b"; Assert.AreEqual(true, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("Level Next Next Name x: b y: a", tracker.Diff.ToString("", " ")); y.Next.Next.Name = "b"; Assert.AreEqual(false, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual(null, tracker.Diff); } }
/// <summary> /// Initializes a new instance of the <see cref="MemberSettings"/> class. /// </summary> /// <param name="ignoredMembers">A collection of members to ignore. Can be null.</param> /// <param name="ignoredTypes">A collection of types to ignore. Can be null.</param> /// <param name="immutableTypes">A collection of types to treat as immutable. Can be null.</param> /// <param name="comparers">A map of types with custom comparers. Can be null.</param> /// <param name="copyers">A map of custom copy implementations for types. Can be null.</param> /// <param name="referenceHandling">How reference values are handled.</param> /// <param name="bindingFlags">The bindingflags used for getting members.</param> protected MemberSettings( IEnumerable<MemberInfo> ignoredMembers, IEnumerable<Type> ignoredTypes, IEnumerable<Type> immutableTypes, IReadOnlyDictionary<Type, CastingComparer> comparers, IReadOnlyDictionary<Type, CustomCopy> copyers, ReferenceHandling referenceHandling, BindingFlags bindingFlags) { this.ReferenceHandling = referenceHandling; this.BindingFlags = bindingFlags; if (ignoredMembers != null) { foreach (var ignoredMember in ignoredMembers) { this.ignoredMembers.TryAdd(ignoredMember, true); } } this.ignoredTypes = IgnoredTypes.Create(ignoredTypes); this.immutableTypes = ImmutableSet<Type>.Create(immutableTypes); this.comparers = comparers; this.copyers = copyers; }
public BindingFlagsAndReferenceHandling(BindingFlags bindingFlags, ReferenceHandling referenceHandling) { this.bindingFlags = bindingFlags; this.referenceHandling = referenceHandling; }
public void Replace(ReferenceHandling referenceHandling) { var source = new ObservableCollection<int> { 1, 2 }; var target = new ObservableCollection<int> { 1, 2 }; using (Synchronize.PropertyValues(source, target, referenceHandling)) { source[0] = 3; CollectionAssert.AreEqual(new[] { 3, 2 }, source); CollectionAssert.AreEqual(new[] { 3, 2 }, target); source[1] = 4; CollectionAssert.AreEqual(new[] { 3, 4 }, source); CollectionAssert.AreEqual(new[] { 3, 4 }, target); } }
public void Replace(ReferenceHandling referenceHandling) { var source = new ObservableCollection<ComplexType> { new ComplexType("a", 1), new ComplexType("b", 2) }; var target = new ObservableCollection<ComplexType> { new ComplexType("a", 1), new ComplexType("b", 2) }; using (Synchronize.PropertyValues(source, target, referenceHandling)) { source[0] = new ComplexType("c", 3); var expected = new[] { new ComplexType("c", 3), new ComplexType("b", 2) }; CollectionAssert.AreEqual(expected, source, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target, ComplexType.Comparer); source[1] = new ComplexType("d", 4); expected = new[] { new ComplexType("c", 3), new ComplexType("d", 4) }; CollectionAssert.AreEqual(expected, source, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target, ComplexType.Comparer); } }
public void MoveThenUpdate(ReferenceHandling referenceHandling) { var source = new ObservableCollection<ComplexType> { new ComplexType("a", 1), new ComplexType("b", 2), new ComplexType("c", 3) }; var target = new ObservableCollection<ComplexType> { new ComplexType("a", 1), new ComplexType("b", 2), new ComplexType("c", 3) }; using (Synchronize.PropertyValues(source, target, referenceHandling)) { source.Move(2, 0); var expected = new[] { new ComplexType("c", 3), new ComplexType("a", 1), new ComplexType("b", 2) }; CollectionAssert.AreEqual(expected, source, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target, ComplexType.Comparer); source[0].Value++; expected = new[] { new ComplexType("c", 4), new ComplexType("a", 1), new ComplexType("b", 2) }; CollectionAssert.AreEqual(expected, source, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target, ComplexType.Comparer); source[1].Value++; expected = new[] { new ComplexType("c", 4), new ComplexType("a", 2), new ComplexType("b", 2) }; CollectionAssert.AreEqual(expected, source, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target, ComplexType.Comparer); source[2].Value++; expected = new[] { new ComplexType("c", 4), new ComplexType("a", 2), new ComplexType("b", 3) }; CollectionAssert.AreEqual(expected, source, ComplexType.Comparer); CollectionAssert.AreEqual(expected, target, ComplexType.Comparer); } }
public abstract Diff DiffMethod <T>(T x, T y, ReferenceHandling referenceHandling = ReferenceHandling.Structural, string excludedMembers = null, Type excludedType = null);
public void WithSimpleProperties(ReferenceHandling referenceHandling) { Track.VerifyCanTrackChanges<WithSimpleProperties>(referenceHandling); Track.VerifyCanTrackChanges<WithSimpleProperties>(PropertiesSettings.GetOrCreate(referenceHandling)); Track.VerifyCanTrackChanges(typeof(WithSimpleProperties), PropertiesSettings.GetOrCreate(referenceHandling)); }
public void Caches(BindingFlags bindingFlags, ReferenceHandling referenceHandling) { var settings = PropertiesSettings.GetOrCreate(referenceHandling, bindingFlags); Assert.AreEqual(bindingFlags, settings.BindingFlags); Assert.AreEqual(referenceHandling, settings.ReferenceHandling); var second = PropertiesSettings.GetOrCreate(referenceHandling, BindingFlags.Public); Assert.AreSame(settings, second); }
public AbstractDictionaryConverter(JsonSerializerOptions options) { _keyConverter = options.GetDictionaryKeyConverterRegistry().GetDictionaryKeyConverter <TK>(); _valueConverter = (JsonConverter <TV>)options.GetConverter(typeof(TV)); _referenceHandling = typeof(TV).IsStruct() ? ReferenceHandling.Default : options.GetReferenceHandling(); }
public void TracksNested(ReferenceHandling referenceHandling) { var x = new WithComplexProperty(); var y = new WithComplexProperty(); var changes = new List<string>(); var expectedChanges = new List<string>(); using (var tracker = Track.IsDirty(x, y, referenceHandling)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); CollectionAssert.IsEmpty(changes); x.Name = "newName1"; Assert.AreEqual(true, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("WithComplexProperty Name x: newName1 y: null", tracker.Diff.ToString("", " ")); y.Name = "newName1"; Assert.AreEqual(false, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual(null, tracker.Diff); x.ComplexType = new ComplexType("a", 1); Assert.AreEqual(true, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("WithComplexProperty ComplexType x: Gu.State.Tests.DirtyTrackerTypes+ComplexType y: null", tracker.Diff.ToString("", " ")); y.ComplexType = new ComplexType("a", 1); Assert.AreEqual(false, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual(null, tracker.Diff); x.ComplexType.Name = "newName2"; Assert.AreEqual(true, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("WithComplexProperty ComplexType Name x: newName2 y: a", tracker.Diff.ToString("", " ")); x.ComplexType.Value++; Assert.AreEqual(true, tracker.IsDirty); expectedChanges.Add("Diff"); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("WithComplexProperty ComplexType Name x: newName2 y: a Value x: 2 y: 1", tracker.Diff.ToString("", " ")); y.ComplexType.Name = "newName2"; Assert.AreEqual(true, tracker.IsDirty); expectedChanges.Add("Diff"); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("WithComplexProperty ComplexType Value x: 2 y: 1", tracker.Diff.ToString("", " ")); y.ComplexType.Value++; Assert.AreEqual(false, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual(null, tracker.Diff); } }
public void HandlesMissingProperty(ReferenceHandling referenceHandling) { var source = new WithSimpleProperties { IntValue = 1, StringValue = "2" }; var target = new WithSimpleProperties { IntValue = 3, StringValue = "4" }; using (Synchronize.PropertyValues(source, target, referenceHandling)) { Assert.AreEqual(1, source.IntValue); Assert.AreEqual(1, target.IntValue); Assert.AreEqual("2", source.StringValue); Assert.AreEqual("2", target.StringValue); source.OnPropertyChanged("Missing"); source.IntValue = 5; Assert.AreEqual(5, source.IntValue); Assert.AreEqual(5, target.IntValue); Assert.AreEqual("2", source.StringValue); Assert.AreEqual("2", target.StringValue); } source.IntValue = 6; Assert.AreEqual(6, source.IntValue); Assert.AreEqual(5, target.IntValue); Assert.AreEqual("2", source.StringValue); Assert.AreEqual("2", target.StringValue); }
public override bool EqualByMethod <T, TValue>(T x, T y, IEqualityComparer <TValue> comparer, ReferenceHandling referenceHandling = ReferenceHandling.Structural) { var settings = PropertiesSettings.Build() .AddComparer(comparer) .CreateSettings(referenceHandling); return(EqualBy.PropertyValues(x, y, settings)); }
public void TracksNested(ReferenceHandling referenceHandling) { var x = new WithComplexProperty(); var y = new WithComplexProperty(); var changes = new List <string>(); var expectedChanges = new List <string>(); using (var tracker = Track.IsDirty(x, y, referenceHandling)) { tracker.PropertyChanged += (_, e) => changes.Add(e.PropertyName); Assert.AreEqual(false, tracker.IsDirty); Assert.AreEqual(null, tracker.Diff); CollectionAssert.IsEmpty(changes); x.Name = "newName1"; Assert.AreEqual(true, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("WithComplexProperty Name x: newName1 y: null", tracker.Diff.ToString("", " ")); y.Name = "newName1"; Assert.AreEqual(false, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual(null, tracker.Diff); x.ComplexType = new ComplexType("a", 1); Assert.AreEqual(true, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("WithComplexProperty ComplexType x: Gu.State.Tests.DirtyTrackerTypes+ComplexType y: null", tracker.Diff.ToString("", " ")); y.ComplexType = new ComplexType("a", 1); Assert.AreEqual(false, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual(null, tracker.Diff); x.ComplexType.Name = "newName2"; Assert.AreEqual(true, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("WithComplexProperty ComplexType Name x: newName2 y: a", tracker.Diff.ToString("", " ")); x.ComplexType.Value++; Assert.AreEqual(true, tracker.IsDirty); expectedChanges.Add("Diff"); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("WithComplexProperty ComplexType Name x: newName2 y: a Value x: 2 y: 1", tracker.Diff.ToString("", " ")); y.ComplexType.Name = "newName2"; Assert.AreEqual(true, tracker.IsDirty); expectedChanges.Add("Diff"); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual("WithComplexProperty ComplexType Value x: 2 y: 1", tracker.Diff.ToString("", " ")); y.ComplexType.Value++; Assert.AreEqual(false, tracker.IsDirty); expectedChanges.AddRange(new[] { "Diff", "IsDirty" }); CollectionAssert.AreEqual(expectedChanges, changes); Assert.AreEqual(null, tracker.Diff); } }
public static JsonSerializerOptions SetReferenceHandling(this JsonSerializerOptions options, ReferenceHandling referenceHandling) { options.GetState().ReferenceHandling = referenceHandling; return(options); }
public void Remove(ReferenceHandling referenceHandling) { var source = new ObservableCollection<WithGetReadOnlyPropertySealed<int>> { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2) }; var target = new ObservableCollection<WithGetReadOnlyPropertySealed<int>> { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2) }; using (Synchronize.PropertyValues(source, target, referenceHandling)) { source.RemoveAt(1); var expected = new[] { new WithGetReadOnlyPropertySealed<int>(1) }; CollectionAssert.AreEqual(expected, source); CollectionAssert.AreEqual(expected, target); source.RemoveAt(0); CollectionAssert.IsEmpty(source); CollectionAssert.IsEmpty(target); } }
public override bool EqualByMethod <T, TValue>(T x, T y, IEqualityComparer <TValue> comparer, ReferenceHandling referenceHandling = ReferenceHandling.Structural) { var builder = FieldsSettings.Build(); builder.AddComparer(comparer); var settings = builder.CreateSettings(referenceHandling); return(EqualBy.FieldValues(x, y, settings)); }