public ConcatObservableToActiveList()
{
_list = ActiveList.Create <T>();
_list.PropertyChanged += (s, e) => _propertyChanged?.Invoke(this, e);
_list.CollectionChanged += (s, e) => _collectionChanged?.Invoke(this, e);
}
public void MutatedListIsCorrectWithoutAnyAppliedChanges()
{
var source = ActiveList.Create(new[] { 1, 2, 3 });
var sut = source.AsActiveValue().ActiveSelect(list => list.Select(i => i * 2));
Assert.True(source.SequenceEqual(sut.Value.Select(i => i / 2)));
}
public void SelectByKeyGroupStaysUpToDateAfterReset()
{
var list = ActiveList.Create(Enumerable.Range(0, 5));
var sut = list.ToActiveLookup(i => i / 10).ActiveSelectByKey(0);
Assert.True(list.SequenceEqual(sut));
list.Reset(new[] { 1, 12, 7, 3, 18 });
Assert.True(new[] { 1, 7, 3 }.SequenceEqual(sut));
}
public void SkipCountAndIncreaseSkip()
{
int raisedCount = 0;
var skipCount = ActiveValue.Create(3);
var list = ActiveList.Create(new[] { 1, 2, 3 });
var sut = list.ActiveSkip(skipCount);
sut.CollectionChanged += (s, e) => ++ raisedCount;
skipCount.Value = 4;
Assert.Equal(0, raisedCount);
}
public void SkipLessThanCountAndDecreaseSkip()
{
int raisedCount = 0;
var skipCount = ActiveValue.Create(2);
var list = ActiveList.Create(new[] { 1, 2, 3 });
var sut = list.ActiveSkip(skipCount);
sut.CollectionChanged += (s, e) => raisedCount += e.Action == NotifyCollectionChangedAction.Add ? 1 : 0;
skipCount.Value = 1;
Assert.Equal(1, raisedCount);
}
public void NewGroupStaysUpToDate()
{
var list = ActiveList.Create(Enumerable.Range(0, 5));
var sut = list.ToActiveLookup(i => i / 10);
Assert.True(new int[0].SequenceEqual(sut[1]));
list.Add(1, 7);
list.Add(2, 15);
Assert.True(new[] { 15 }.SequenceEqual(sut[1]));
}
public void ExistingGroupStaysUpToDate()
{
var list = ActiveList.Create(Enumerable.Range(0, 5));
var sut = list.ToActiveLookup(i => i / 10);
Assert.True(list.SequenceEqual(sut[0]));
list.Add(2, 15);
list.Add(1, 7);
Assert.True(new[] { 0, 7, 1, 2, 3, 4 }.SequenceEqual(sut[0]));
}
public void TakeLessThanCountAndDecreaseTake()
{
int raisedCount = 0;
var takeCount = ActiveValue.Create(2);
var list = ActiveList.Create(new[] { 1, 2, 3 });
var sut = list.ActiveTake(takeCount);
sut.CollectionChanged += (s, e) => raisedCount += e.Action == NotifyCollectionChangedAction.Remove ? 1 : 0;
takeCount.Value = 1;
Assert.Equal(1, raisedCount);
}
public void TakeMoreThanCountAndDecreaseTake()
{
int raisedCount = 0;
var takeCount = ActiveValue.Create(4);
var list = ActiveList.Create(new[] { 1, 2, 3 });
var sut = list.ActiveTake(takeCount);
sut.CollectionChanged += (s, e) => ++ raisedCount;
takeCount.Value = 3;
Assert.Equal(0, raisedCount);
}
public void OrderingInsideGroupMatchesSourceOrdering()
{
var list = ActiveList.Create(Enumerable.Range(0, 5));
var sut = list.ToActiveLookup(i => i / 10);
Assert.True(new int[] { 0, 1, 2, 3, 4 }.SequenceEqual(sut[0]));
list.Add(2, 7);
list.Add(1, 15);
list.Add(0, 9);
Assert.True(new int[] { 9, 0, 1, 7, 2, 3, 4 }.SequenceEqual(sut[0]));
}
public void ChangingParameterStaysUpToDate()
{
var list = ActiveList.Create(Enumerable.Range(5, 10));
var lookup = list.ToActiveLookup(i => i / 10);
var parameter = ActiveValue.Create(0);
var sut = lookup.ActiveSelectByKey(parameter);
Assert.True(list.Take(5).SequenceEqual(sut));
parameter.Value = 1;
Assert.True(list.Skip(5).Take(5).SequenceEqual(sut));
}
public void WithoutPredicateOnlyThrowChangeNotificationWhenValueChanges()
{
var list = ActiveList.Create <int>();
int changeCount = 0;
var sut = list.ActiveAny();
sut.ValueChanged += (s, e) => ++ changeCount;
list.Add(0, 1);
list.Add(0, 2);
list.Clear();
Assert.Equal(2, changeCount);
}
public void NewGroupThrowsChangeNotifications()
{
var list = ActiveList.Create(Enumerable.Range(0, 5));
var sut = list.ToActiveLookup(i => i / 10);
var group = sut[1];
bool changeOccured = false;
group.CollectionChanged += (s, e) => changeOccured = true;
list.Add(1, 7);
Assert.False(changeOccured);
list.Add(2, 15);
Assert.True(changeOccured);
}
public void ChangingParameterThrowsResetNotification()
{
var list = ActiveList.Create(Enumerable.Range(5, 10));
var lookup = list.ToActiveLookup(i => i / 10);
var parameter = ActiveValue.Create(0);
var sut = lookup.ActiveSelectByKey(parameter);
bool changeOccured = false;
sut.CollectionChanged += (s, e) => changeOccured = true;
Assert.False(changeOccured);
parameter.Value = 1;
Assert.True(changeOccured);
}
public void GroupOrderingMatchesSourceOrdering()
{
var list = ActiveList.Create(new[] { 1, 2, 5, 3 });
var sut = list.ToActiveLookup(i => i / 2);
Assert.True(new int[] { 0, 1, 2 }.SequenceEqual(sut.Select(g => g.Key)));
list.Remove(1);
Assert.True(new int[] { 0, 2, 1 }.SequenceEqual(sut.Select(g => g.Key)));
list.Add(4);
Assert.True(new int[] { 0, 2, 1 }.SequenceEqual(sut.Select(g => g.Key)));
list.Move(1, 0);
Assert.True(new int[] { 2, 0, 1 }.SequenceEqual(sut.Select(g => g.Key)));
list.Add(0, 8);
Assert.True(new int[] { 4, 2, 0, 1 }.SequenceEqual(sut.Select(g => g.Key)));
}