public void FilteredProjectedDerivedCollectionsShouldReactToPropertyChanges()
{
// This differs from the FilteredDerivedCollectionsShouldReactToPropertyChanges as it tests providing a
// non-identity selector (ie x=>x.Value).
var a = new ReactiveVisibilityItem <string>("a", true);
var b = new ReactiveVisibilityItem <string>("b", true);
var c = new ReactiveVisibilityItem <string>("c", true);
var items = new ReactiveCollection <ReactiveVisibilityItem <string> >(new[] { a, b, c })
{
ChangeTrackingEnabled = true
};
var onlyVisible = items.CreateDerivedCollection(
x => x.Value.ToUpper(), // Note, not an identity function.
x => x.IsVisible,
StringComparer.Ordinal.Compare
);
Assert.Equal(3, onlyVisible.Count);
Assert.True(onlyVisible.SequenceEqual(new[] { "A", "B", "C" }));
a.IsVisible = false;
Assert.Equal(2, onlyVisible.Count);
Assert.True(onlyVisible.SequenceEqual(new[] { "B", "C" }));
}
public void DerivedCollectionsShouldReactToPropertyChanges()
{
// This differs from the FilteredDerivedCollectionsShouldReactToPropertyChanges as it tests providing a
// non-identity selector (ie x=>x.Value).
var foo = new ReactiveVisibilityItem <string>("Foo", true);
var bar = new ReactiveVisibilityItem <string>("Bar", true);
var baz = new ReactiveVisibilityItem <string>("Baz", true);
var items = new ReactiveCollection <ReactiveVisibilityItem <string> >(new[] { foo, bar, baz })
{
ChangeTrackingEnabled = true
};
var onlyVisible = items.CreateDerivedCollection(
x => new string('*', x.Value.Length), // Note, not an identity function.
x => x.IsVisible,
StringComparer.Ordinal.Compare
);
Assert.Equal(3, onlyVisible.Count);
Assert.True(onlyVisible.SequenceEqual(new[] { "***", "***", "***" }));
foo.IsVisible = false;
Assert.Equal(2, onlyVisible.Count);
Assert.True(onlyVisible.SequenceEqual(new[] { "***", "***" }));
}
public void FilteredDerivedCollectionsShouldReactToPropertyChanges()
{
// Naturally this isn't done by magic, it only works if the source implements IReactiveCollection.
var a = new ReactiveVisibilityItem <string>("a", true);
var b = new ReactiveVisibilityItem <string>("b", true);
var c = new ReactiveVisibilityItem <string>("c", true);
var items = new ReactiveCollection <ReactiveVisibilityItem <string> >(new[] { a, b, c })
{
ChangeTrackingEnabled = true
};
var onlyVisible = items.CreateDerivedCollection(
x => x.Value,
x => x.IsVisible,
StringComparer.Ordinal.Compare
);
var onlyNonVisible = items.CreateDerivedCollection(
x => x.Value,
x => !x.IsVisible,
StringComparer.Ordinal.Compare
);
var onlVisibleStartingWithB = items.CreateDerivedCollection(
x => x.Value,
x => x.IsVisible && x.Value.StartsWith("b"),
StringComparer.Ordinal.Compare
);
Assert.Equal(3, onlyVisible.Count);
Assert.Equal(0, onlyNonVisible.Count);
Assert.Equal(1, onlVisibleStartingWithB.Count);
a.IsVisible = false;
Assert.Equal(2, onlyVisible.Count);
Assert.Equal(1, onlyNonVisible.Count);
Assert.Equal(1, onlVisibleStartingWithB.Count);
b.Value = "D";
Assert.Equal(0, onlVisibleStartingWithB.Count);
}
public void DerivedCollectionShouldHandleRemovesOfFilteredItems()
{
var a = new ReactiveVisibilityItem <string>("A", true);
var b = new ReactiveVisibilityItem <string>("B", true);
var c = new ReactiveVisibilityItem <string>("C", true);
var d = new ReactiveVisibilityItem <string>("D", false);
var e = new ReactiveVisibilityItem <string>("E", true);
var items = new ReactiveCollection <ReactiveVisibilityItem <string> >(new[] { a, b, c, d, e })
{
ChangeTrackingEnabled = true
};
var onlyVisible = items.CreateDerivedCollection(
x => x.Value,
x => x.IsVisible,
OrderedComparer <string> .OrderByDescending(x => x).Compare
);
Assert.True(onlyVisible.SequenceEqual(new[] { "E", "C", "B", "A" }, StringComparer.Ordinal));
Assert.Equal(4, onlyVisible.Count);
// Removal of an item from the source collection that's filtered in the derived collection should
// have no effect on the derived.
items.Remove(d);
Assert.True(onlyVisible.SequenceEqual(new[] { "E", "C", "B", "A" }, StringComparer.Ordinal));
Assert.Equal(4, onlyVisible.Count);
c.IsVisible = false;
Assert.Equal(3, onlyVisible.Count);
Assert.True(onlyVisible.SequenceEqual(new[] { "E", "B", "A" }, StringComparer.Ordinal));
items.Remove(c);
Assert.Equal(3, onlyVisible.Count);
Assert.True(onlyVisible.SequenceEqual(new[] { "E", "B", "A" }, StringComparer.Ordinal));
items.Remove(b);
Assert.Equal(2, onlyVisible.Count);
Assert.True(onlyVisible.SequenceEqual(new[] { "E", "A" }, StringComparer.Ordinal));
}
