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