public async Task Add_to_projected_set()
        {
            var list = new SortedSetReactiveCollectionSource<int>();

            var projectedList = list.ReactiveCollection
                .Select(x => x.ToString(CultureInfo.InvariantCulture));

            var notificationsTask = projectedList.Changes
                .Take(4)
                .ToArray()
                .ToTask();

            list.Add(1);
            list.Add(2);
            list.Add(3);

            var notifications = await notificationsTask;

            notifications[0].Index.Should().NotHaveValue();
            notifications[1].Index.Should().Be(0);
            notifications[2].Index.Should().Be(1);
            notifications[3].Index.Should().Be(2);
            notifications[0].Action.Should().Be(NotifyCollectionChangedAction.Reset);
            notifications[1].Action.Should().Be(NotifyCollectionChangedAction.Add);
            notifications[2].Action.Should().Be(NotifyCollectionChangedAction.Add);
            notifications[3].Action.Should().Be(NotifyCollectionChangedAction.Add);
            notifications[0].NewItems.Should().BeEmpty();
            notifications[1].NewItems.Should().Equal("1");
            notifications[2].NewItems.Should().Equal("2");
            notifications[3].NewItems.Should().Equal("3");
        }
Beispiel #2
0
        public async Task First_notification_is_reset()
        {
            var list = new SortedSetReactiveCollectionSource <int>();

            var notificationsTask = await list.ReactiveCollection.Changes
                                    .FirstAsync()
                                    .ToTask();

            await Verify(notificationsTask);
        }
        public async Task First_notification_is_reset()
        {
            var list = new SortedSetReactiveCollectionSource<int>();

            var notification = await list.ReactiveCollection.Changes.FirstAsync().ToTask();

            notification.Action.Should().Be(NotifyCollectionChangedAction.Reset);
            notification.OldItems.Should().BeEmpty();
            notification.NewItems.Should().BeEmpty();
            notification.Current.Should().BeEmpty();
        }
Beispiel #4
0
        public async Task First_notification_is_reset()
        {
            var list = new SortedSetReactiveCollectionSource <int>();

            var notification = await list.ReactiveCollection.Changes.FirstAsync().ToTask();

            notification.Action.Should().Be(NotifyCollectionChangedAction.Reset);
            notification.OldItems.Should().BeEmpty();
            notification.NewItems.Should().BeEmpty();
            notification.Current.Should().BeEmpty();
        }
Beispiel #5
0
        public async Task Add()
        {
            var list = new SortedSetReactiveCollectionSource <int>();

            var notificationsTask = list.ReactiveCollection.Changes
                                    .Take(2)
                                    .ToArray()
                                    .ToTask();

            list.Add(1);

            await Verify(notificationsTask);
        }
Beispiel #6
0
        public async Task Clear_preserves_comparer()
        {
            var list = new SortedSetReactiveCollectionSource <StructNotImplementingIComparable>(new Comparison <StructNotImplementingIComparable>((x, y) => x.Value.CompareTo(y.Value)).ToComparer());

            list.Add(new StructNotImplementingIComparable(1));
            list.Clear();
            list.Add(new StructNotImplementingIComparable(2));
            list.Add(new StructNotImplementingIComparable(1));

            var current = (await list.ReactiveCollection.Changes.FirstAsync()).Current.Select(x => x.Value).ToArray();

            current.Should().Equal(1, 2);
        }
Beispiel #7
0
        public async Task Clear()
        {
            var list = new SortedSetReactiveCollectionSource <int>();

            var notificationsTask = list.ReactiveCollection.Changes
                                    .Take(3)
                                    .FirstAsync()
                                    .ToTask();

            list.Add(1);
            list.Clear();

            await Verify(notificationsTask);
        }
Beispiel #8
0
        public async Task Clear_preserves_comparer()
        {
            var list = new SortedSetReactiveCollectionSource <StructNotImplementingIComparable>(new Comparison <StructNotImplementingIComparable>((x, y) => x.Value.CompareTo(y.Value)).ToComparer());

            var notificationsTask = list.ReactiveCollection.Changes
                                    .Take(5)
                                    .ToArray()
                                    .ToTask();

            list.Add(new StructNotImplementingIComparable(1));
            list.Clear();
            list.Add(new StructNotImplementingIComparable(2));
            list.Add(new StructNotImplementingIComparable(1));

            await Verify(notificationsTask);
        }
        public async Task Add()
        {
            var list = new SortedSetReactiveCollectionSource<int>();

            var notificationTask = list.ReactiveCollection.Changes
                .Skip(1)
                .FirstAsync()
                .ToTask();

            list.Add(1);

            var notification = await notificationTask;

            notification.Action.Should().Be(NotifyCollectionChangedAction.Add);
            notification.Index.Should().Be(0);
            notification.NewItems.Should().Equal(1);
            notification.Current.Should().Equal(1);
        }
Beispiel #10
0
        public async Task Add()
        {
            var list = new SortedSetReactiveCollectionSource <int>();

            var notificationTask = list.ReactiveCollection.Changes
                                   .Skip(1)
                                   .FirstAsync()
                                   .ToTask();

            list.Add(1);

            var notification = await notificationTask;

            notification.Action.Should().Be(NotifyCollectionChangedAction.Add);
            notification.Index.Should().Be(0);
            notification.NewItems.Should().Equal(1);
            notification.Current.Should().Equal(1);
        }
Beispiel #11
0
        public async Task Clear()
        {
            var list = new SortedSetReactiveCollectionSource <int>();

            var notificationTask = list.ReactiveCollection.Changes
                                   .Skip(2)
                                   .FirstAsync()
                                   .ToTask();

            list.Add(1);
            list.Clear();

            var notification = await notificationTask;

            notification.Action.Should().Be(NotifyCollectionChangedAction.Reset);
            notification.NewItems.Should().BeEmpty();
            notification.OldItems.Should().BeEmpty();
            notification.Current.Should().BeEmpty();
        }
Beispiel #12
0
        public async Task Add_multiple()
        {
            var list = new SortedSetReactiveCollectionSource <int>();

            var notificationsTask = list.ReactiveCollection.Changes
                                    .Take(7)
                                    .Select(x => x.Index)
                                    .ToArray()
                                    .ToTask();

            list.Add(1); // 0
            list.Add(3); // 1
            list.Add(2); // 1
            list.Add(0); // 0
            list.Add(6); // 4
            list.Add(5); // 4

            await Verify(notificationsTask);
        }
        public async Task Clear()
        {
            var list = new SortedSetReactiveCollectionSource<int>();

            var notificationTask = list.ReactiveCollection.Changes
                .Skip(2)
                .FirstAsync()
                .ToTask();

            list.Add(1);
            list.Clear();

            var notification = await notificationTask;

            notification.Action.Should().Be(NotifyCollectionChangedAction.Reset);
            notification.NewItems.Should().BeEmpty();
            notification.OldItems.Should().BeEmpty();
            notification.Current.Should().BeEmpty();
        }
        public async Task Add_multiple()
        {
            var list = new SortedSetReactiveCollectionSource<int>();

            var notificationTask = list.ReactiveCollection.Changes
                .Skip(1)
                .Take(6)
                .Select(x => x.Index)
                .ToArray()
                .ToTask();

            list.Add(1); // 0
            list.Add(3); // 1
            list.Add(2); // 1
            list.Add(0); // 0
            list.Add(6); // 4
            list.Add(5); // 4

            var notifications = await notificationTask;

            notifications.Should().BeEquivalentTo(new[] { 0, 1, 1, 0, 4, 4 });
        }
Beispiel #15
0
        public async Task Add_multiple()
        {
            var list = new SortedSetReactiveCollectionSource <int>();

            var notificationTask = list.ReactiveCollection.Changes
                                   .Skip(1)
                                   .Take(6)
                                   .Select(x => x.Index)
                                   .ToArray()
                                   .ToTask();

            list.Add(1); // 0
            list.Add(3); // 1
            list.Add(2); // 1
            list.Add(0); // 0
            list.Add(6); // 4
            list.Add(5); // 4

            var notifications = await notificationTask;

            notifications.Should().BeEquivalentTo(new[] { 0, 1, 1, 0, 4, 4 });
        }
        public async Task SortedSet_ToObservableCollection_Remove()
        {
            var list = new SortedSetReactiveCollectionSource<int>();
            var observableCollection = (INotifyCollectionChanged)list.ReactiveCollection.ToObservableCollection();

            var eventsTask = Observable
                .FromEventPattern<NotifyCollectionChangedEventHandler, NotifyCollectionChangedEventArgs>(eh => observableCollection.CollectionChanged += eh, eh => observableCollection.CollectionChanged -= eh)
                .Take(3)
                .Select(x => x.EventArgs)
                .ToArray()
                .ToTask();

            list.Add(1);
            list.Add(2);
            list.Remove(1);

            var events = await eventsTask;

            events[0].Action.Should().Be(NotifyCollectionChangedAction.Add);
            events[1].Action.Should().Be(NotifyCollectionChangedAction.Add);
            events[2].Action.Should().Be(NotifyCollectionChangedAction.Remove);
        }
        public void SortedSet_ToObservableCollection_Remove_multiple()
        {
            var list = new SortedSetReactiveCollectionSource<int>();
            var observableCollection = list.ReactiveCollection.ToObservableCollection();

            using (Observable
                .FromEventPattern<NotifyCollectionChangedEventHandler, NotifyCollectionChangedEventArgs>(eh => ((INotifyCollectionChanged)observableCollection).CollectionChanged += eh, eh => ((INotifyCollectionChanged)observableCollection).CollectionChanged -= eh)
                .Subscribe())
            {
                list.AddRange(new[] { 1, 2, 3, 4, 5, 6, 7 });
                list.Remove(3);
                list.Remove(4);
                list.Remove(5);

                observableCollection.Should().Equal(1, 2, 6, 7);
            }
        }
        public async Task Clear_preserves_comparer()
        {
            var list = new SortedSetReactiveCollectionSource<StructNotImplementingIComparable>(new Comparison<StructNotImplementingIComparable>((x, y) => x.Value.CompareTo(y.Value)).ToComparer());

            list.Add(new StructNotImplementingIComparable(1));
            list.Clear();
            list.Add(new StructNotImplementingIComparable(2));
            list.Add(new StructNotImplementingIComparable(1));

            var current = (await list.ReactiveCollection.Changes.FirstAsync()).Current.Select(x => x.Value).ToArray();

            current.Should().Equal(1, 2);
        }
        public async Task Remove_from_projected_set()
        {
            var list = new SortedSetReactiveCollectionSource<int>();

            var projectedList = list.ReactiveCollection
                .Select(x => x.ToString(CultureInfo.InvariantCulture));

            var notificationTask = projectedList.Changes
                .Skip(4)
                .FirstAsync()
                .ToTask();

            list.Add(1);
            list.Add(2);
            list.Add(3);
            list.Remove(2);

            var notification = await notificationTask;

            notification.Index.Should().Be(1);
            notification.Action.Should().Be(NotifyCollectionChangedAction.Remove);
            notification.NewItems.Should().BeEmpty();
            notification.OldItems.Should().Equal("2");
            notification.Current.Should().Equal("1", "3");
        }
        public async Task Remove_from_filtered_set()
        {
            var list = new SortedSetReactiveCollectionSource<int>();

            var projectedList = list
                .ReactiveCollection
                .Where(x => x % 2 == 0);

            var notificationTask = projectedList.Changes
                .Skip(2)
                .FirstAsync()
                .ToTask();

            list.Add(1);
            list.Add(2);
            list.Add(3);
            list.Remove(2);

            var notification = await notificationTask;

            notification.Index.Should().Be(0);
            notification.Action.Should().Be(NotifyCollectionChangedAction.Remove);
            notification.OldItems.Should().Equal(2);
            notification.NewItems.Should().BeEmpty();
            notification.Current.Should().BeEmpty();
        }