public void NotCrashWhenItemsSourceIsNullAndFilteredItemsIsCleared()
{
var filter = new ObservableListFilter <TestClass>();
filter.FilterFunction.Should().NotBeNull();
filter.ItemsSource.Should().BeNull();
filter.FilteredItems.Clear();
filter.FilteredItems.Should().BeEmpty();
}
public void NotAddToTheFilterWhenItemsSourceIsNull()
{
var filter = new ObservableListFilter <TestClass>
{
FilterFunction = _ => _.Value % 2 == 0,
ItemsSource = null
};
filter.FilteredItems.Add(Items[2]);
VerifyItems(filter.FilteredItems, Array.Empty <int>());
}
public void RetainReferenceOfItemsSource()
{
var itemsSource = new ObservableList <object>();
var filter = new ObservableListFilter <object>();
filter.ItemsSource.Should().BeNull();
filter.ItemsSource = itemsSource;
Assert.AreSame(filter.ItemsSource, itemsSource);
}
public void RetainFilterFunction()
{
// ReSharper disable once ConvertToLocalFunction => Does not help in this case.
Func <object, bool> ff = x => true;
var filter = new ObservableListFilter <object>();
filter.FilterFunction.Should().NotBe(ff);
filter.FilterFunction = ff;
filter.FilterFunction.Should().Be(ff);
}
public void NotCrashWhenFilterFunctionIsNullAndFilteredItemsIsCleared()
{
var filter = new ObservableListFilter <TestClass>
{
FilterFunction = null,
ItemsSource = new ObservableList <TestClass>()
};
filter.ItemsSource.Add(Items[2]);
filter.FilteredItems.Clear();
filter.FilteredItems.Should().BeEmpty();
}
private ObservableListFilter <TestClass> CreateFilterWithItems(int[] initialValues, Func <int, TestClass> itemSelector)
{
var filter = new ObservableListFilter <TestClass>
{
FilterFunction = _ => _.Value % 2 == 0,
ItemsSource = new ObservableList <TestClass>()
};
foreach (var initialValue in initialValues)
{
filter.ItemsSource.Add(itemSelector(initialValue));
}
return(filter);
}
public void AddingItemToItemsSourceShouldBeAddedToFilteredItemsWhenMatchingFilter()
{
var itemsSource = new ObservableList <TestClass>();
var filter = new ObservableListFilter <TestClass>
{
FilterFunction = _ => _.Value % 2 == 0,
ItemsSource = itemsSource
};
var item = new TestClass {
Value = 2
};
itemsSource.Add(item);
filter.FilteredItems.Should().Contain(item).And.HaveCount(1);
}
public void AddingItemToItemsSourceShouldNotBeAddedToFilteredItemsWhenNotMatchingFilter()
{
var itemsSource = new ObservableList <TestClass>();
var filter = new ObservableListFilter <TestClass>
{
FilterFunction = _ => _.Value % 2 == 0,
ItemsSource = itemsSource
};
var item = new TestClass {
Value = 1
};
itemsSource.Add(item);
filter.FilteredItems.Should().BeEmpty();
}
private void VerifyItemsSourceItemUpdate(int initialValue, int newValue, int[] correctItemsSource, int[] correctFilteredItems)
{
var filter = new ObservableListFilter <TestClass>
{
FilterFunction = _ => _.Value % 2 == 0,
ItemsSource = new ObservableList <TestClass>()
};
filter.ItemsSource.Add(new TestClass {
Value = initialValue
});
filter.ItemsSource[0].Value = newValue;
filter.ItemsSource.ItemUpdateAt(0);
VerifyItems(filter.FilteredItems, correctFilteredItems);
VerifyItems(filter.ItemsSource, correctItemsSource);
}
public void NotCheckFilterFunctionForEquality()
{
/*
* In certain conditions, the filter function can be the same object but still evaluate differently compared
* to the previous run, so we should not make any decision based on the equality of the two functions to
* reapply the filter to the items or not. Consider the following:
*
* public class Data
* {
* public DateTime DateTime { get; set; }
* }
*
* private static readonly Data data = new Data();
* private static Func<DateTime, bool> F4()
* {
* return dt => data.DateTime == dt;
* }
*
* [Test]
* public void X4()
* {
* Func<DateTime, bool> f1 = F3();
* Func<DateTime, bool> f2 = F3();
* Assert.IsTrue(f1 == f2);
* }
*
* The assertion is passing (the two functions are equal), while between the two actual object creation
* nothing stops us from updating the data.DateTime property to a different value.
* */
// ReSharper disable once ConvertToLocalFunction => No, we want to test this with a Func object.
Func <TestClass, bool> filterFunction = _ => true;
var filter = new ObservableListFilter <TestClass>
{
FilterFunction = filterFunction,
ItemsSource = new ObservableList <TestClass>()
};
var monitor = filter.FilteredItems.Monitor();
filter.FilterFunction = filterFunction;
monitor.Should().Raise(nameof(ObservableList <TestClass> .CollectionChanged));
}
public void BeAbleToFunctionWithMultipleObservers()
{
var filter = new ObservableListFilter <TestClass>
{
FilterFunction = _ => _.Value % 2 == 0,
ItemsSource = new ObservableList <TestClass> {
new TestClass {
Value = 2
}
}
};
filter.FilteredItems.CollectionChanged += delegate
{
// Observer
};
filter.FilteredItems.Clear();
}
public void RebuildFilteredItemsOnFilterFunctionChange()
{
var filter = new ObservableListFilter <TestClass>
{
FilterFunction = _ => _.Value % 2 == 0,
ItemsSource = new ObservableList <TestClass>()
};
for (var i = 0; i < 10; ++i)
{
filter.ItemsSource.Add(new TestClass {
Value = i
});
}
VerifyItems(filter.FilteredItems, new[] { 0, 2, 4, 6, 8 });
filter.FilterFunction = _ => _.Value % 2 == 1;
VerifyItems(filter.FilteredItems, new[] { 1, 3, 5, 7, 9 });
}
public void AddItemToCorrectLocationWhenAllItemsAreMatchingFilter()
{
var filter = new ObservableListFilter <TestClass>
{
ItemsSource = new ObservableList <TestClass>()
};
var item1 = new TestClass {
Value = 1
};
var item2 = new TestClass {
Value = 2
};
var item3 = new TestClass {
Value = 3
};
filter.ItemsSource.Add(item1);
filter.ItemsSource.Add(item3);
filter.ItemsSource.Insert(1, item2);
filter.FilteredItems.Should().ContainInOrder(item1, item2, item3).And.HaveCount(3);
}
public void DefaultFilteredSourceToEmpty()
{
var filter = new ObservableListFilter <object>();
filter.FilteredItems.Should().BeEmpty();
}
private void VerifyThatItemsSourceAndFilteredItemsOrderMatch(ObservableListFilter <TestClass> filter)
{
VerifyItems(
filter.FilteredItems,
filter.ItemsSource.Where(_ => _.Value % 2 == 0).Select(_ => _.Value).ToArray());
}
public void HaveDefaultFilterAsNotNull()
{
var filter = new ObservableListFilter <object>();
filter.FilterFunction.Should().NotBeNull();
}
public void BeConstructable()
{
var unused = new ObservableListFilter <object>();
}
