using System;

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Reactive.Linq;

using System.Text;

using ReactiveUI.Testing;

using Xunit;

using Splat;

using Microsoft.Reactive.Testing;

using System.Collections.Specialized;

using System.Reactive.Subjects;

using System.Reactive;

using System.Diagnostics;

using System.Threading;

using System.Reactive.Disposables;

namespace ReactiveUI.Tests

{

public class FakeCollectionModel : ReactiveObject

{

bool isHidden;

public bool IsHidden {

get { return isHidden; }

set { this.RaiseAndSetIfChanged(ref isHidden, value); }

}

int someNumber;

public int SomeNumber {

get { return someNumber; }

set { this.RaiseAndSetIfChanged(ref someNumber, value); }

}

}

public class FakeCollectionViewModel : ReactiveObject

{

public FakeCollectionModel Model { get; protected set; }

ObservableAsPropertyHelper<string> numberAsString;

public string NumberAsString {

get { return numberAsString.Value; }

}

public FakeCollectionViewModel(FakeCollectionModel model)

{

Model = model;

this.WhenAny(x => x.Model.SomeNumber, x => x.Value.ToString())

.ToProperty(this, x => x.NumberAsString, out numberAsString);

}

}

class NestedTextModel : ReactiveObject

{

string text;

public string Text {

get { return text; }

set { this.RaiseAndSetIfChanged(ref text, value); }

}

bool hasData;

public bool HasData {

get { return hasData; }

set { this.RaiseAndSetIfChanged(ref hasData, value); }

}

}

class TextModel : ReactiveObject

{

NestedTextModel value;

public NestedTextModel Value {

get {

if (value != null) return value;

var newValue =

value = new NestedTextModel() {

Text = "text",

HasData = true

};

this.RaiseAndSetIfChanged(ref value, newValue);

return value;

}

}

public bool HasData {

get { return Value.HasData; }

}

public TextModel()

{

this.WhenAnyValue(x => x.Value.HasData)

.Subscribe(_ => this.RaisePropertyChanged("HasData"));

}

}

public class ReactiveCollectionTest

{

[Fact]

public void CountPropertyIsNotAmbiguous()

{

IReactiveList<int> reactiveList = new ReactiveList<int>();

Assert.Equal(0, reactiveList.Count);

IList<int> list = reactiveList;

Assert.Equal(0, list.Count);

ICollection collection = new ReactiveList<int>();

var l = (IList) collection;

Assert.Same(collection, l);

}

[Fact]

public void IndexerIsNotAmbiguous()

{

IReactiveList<int> reactiveList = new ReactiveList<int> { 0, 1 };

Assert.Equal(0, reactiveList[0]);

}

[Fact]

public void CollectionCountChangedTest()

{

var fixture = new ReactiveList<int>();

var before_output = new List<int>();

var output = new List<int>();

fixture.CountChanging.Subscribe(before_output.Add);

fixture.CountChanged.Subscribe(output.Add);

fixture.Add(10);

fixture.Add(20);

fixture.Add(30);

fixture.RemoveAt(1);

fixture.Clear();

var before_results = new[] {0,1,2,3,2};

Assert.Equal(before_results.Length, before_output.Count);

before_results.AssertAreEqual(before_output);

var results = new[]{1,2,3,2,0};

Assert.Equal(results.Length, output.Count);

results.AssertAreEqual(output);

}

[Fact]

public void CollectionCountChangedFiresWhenClearing()

{

var items = new ReactiveList<object>(new []{new object()});

bool countChanged = false;

items.CountChanged.Subscribe(_ => {countChanged = true;});

items.Clear();

Assert.True(countChanged);

}

[Fact]

public void WhenAddingRangeOfNullArgumentNullExceptionIsThrown()

{

var fixture = new ReactiveList<int>();

Assert.Throws<ArgumentNullException>(() => fixture.AddRange(null));

}

[Fact]

public void WhenRemovingAllOfNullArgumentNullExceptionIsThrown()

{

var fixture = new ReactiveList<int>();

Assert.Throws<ArgumentNullException>(() => fixture.RemoveAll(null));

}

[Fact]

public void WhenInsertingRangeOfNullArgumentNullExceptionIsThrown()

{

var fixture = new ReactiveList<int>();

Assert.Throws<ArgumentNullException>(() => fixture.InsertRange(1,null));

}

[Fact]

public void WhenInsertingRangeOutOfRangeExceptionIsThrown()

{

var fixture = new ReactiveList<int>();

Assert.Throws<ArgumentOutOfRangeException>(() => fixture.InsertRange(1, new List<int>() { 1 }));

}

[Fact]

public void ItemsAddedAndRemovedTest()

{

var fixture = new ReactiveList<int>();

var before_added = new List<int>();

var before_removed = new List<int>();

var added = new List<int>();

var removed = new List<int>();

fixture.BeforeItemsAdded.Subscribe(before_added.Add);

fixture.BeforeItemsRemoved.Subscribe(before_removed.Add);

fixture.ItemsAdded.Subscribe(added.Add);

fixture.ItemsRemoved.Subscribe(removed.Add);

fixture.Add(10);

fixture.Add(20);

fixture.Add(30);

fixture.RemoveAt(1);

fixture.Clear();

var added_results = new[]{10,20,30};

Assert.Equal(added_results.Length, added.Count);

added_results.AssertAreEqual(added);

var removed_results = new[]{20};

Assert.Equal(removed_results.Length, removed.Count);

removed_results.AssertAreEqual(removed);

Assert.Equal(before_added.Count, added.Count);

added.AssertAreEqual(before_added);

Assert.Equal(before_removed.Count, removed.Count);

removed.AssertAreEqual(before_removed);

}

#if !SILVERLIGHT

[Fact]

public void MoveShouldBehaveAsObservableCollectionMove()

{

var items = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

var fixture = new ReactiveList<int>(items);

var reference = new System.Collections.ObjectModel.ObservableCollection<int>(items);

Assert.True(fixture.SequenceEqual(reference));

var fixtureNotifications = new List<NotifyCollectionChangedEventArgs>();

var referenceNotifications = new List<NotifyCollectionChangedEventArgs>();

fixture.Changed.Subscribe(fixtureNotifications.Add);

Observable.FromEventPattern<NotifyCollectionChangedEventHandler, NotifyCollectionChangedEventArgs>(

x => reference.CollectionChanged += x,

x => reference.CollectionChanged -= x)

.Select(x=> x.EventArgs)

.Subscribe(referenceNotifications.Add);

for (int i = 0; i < items.Length; i++) {

for (int j = 0; j < items.Length; j++) {

reference.Move(i, j);

fixture.Move(i, j);

Assert.True(fixture.SequenceEqual(reference));

Assert.Equal(fixtureNotifications.Count, referenceNotifications.Count);

var lastFixtureNotification = fixtureNotifications.Last();

var lastReferenceNotification = referenceNotifications.Last();

Assert.Equal(NotifyCollectionChangedAction.Move, lastFixtureNotification.Action);

Assert.Equal(NotifyCollectionChangedAction.Move, lastReferenceNotification.Action);

Assert.Equal(lastFixtureNotification.OldStartingIndex, lastReferenceNotification.OldStartingIndex);

Assert.Equal(lastFixtureNotification.NewStartingIndex, lastReferenceNotification.NewStartingIndex);

Assert.Equal(lastReferenceNotification.OldItems[0], lastReferenceNotification.OldItems[0]);

Assert.Equal(lastReferenceNotification.NewItems[0], lastReferenceNotification.NewItems[0]);

}

}

}

#endif

[Fact]

public void ReactiveCollectionIsRoundTrippable()

{

var output = new[] {"Foo", "Bar", "Baz", "Bamf"};

var fixture = new ReactiveList<string>(output);

string json = JSONHelper.Serialize(fixture);

var results = JSONHelper.Deserialize<ReactiveList<string>>(json);

output.AssertAreEqual(results);

bool should_die = true;

results.ItemsAdded.Subscribe(_ => should_die = false);

results.Add("Foobar");

Assert.False(should_die);

}

[Fact]

public void ChangeTrackingShouldFireNotifications()

{

var fixture = new ReactiveList<TestFixture>() { ChangeTrackingEnabled = true };

var before_output = new List<Tuple<TestFixture, string>>();

var output = new List<Tuple<TestFixture, string>>();

var item1 = new TestFixture() { IsOnlyOneWord = "Foo" };

var item2 = new TestFixture() { IsOnlyOneWord = "Bar" };

fixture.ItemChanging.Subscribe(x => {

before_output.Add(new Tuple<TestFixture,string>((TestFixture)x.Sender, x.PropertyName));

});

fixture.ItemChanged.Subscribe(x => {

output.Add(new Tuple<TestFixture,string>((TestFixture)x.Sender, x.PropertyName));

});

fixture.Add(item1);

fixture.Add(item2);

item1.IsOnlyOneWord = "Baz";

Assert.Equal(1, output.Count);

item2.IsNotNullString = "FooBar";

Assert.Equal(2, output.Count);

fixture.Remove(item2);

item2.IsNotNullString = "FooBarBaz";

Assert.Equal(2, output.Count);

fixture.ChangeTrackingEnabled = false;

item1.IsNotNullString = "Bamf";

Assert.Equal(2, output.Count);

new[]{item1, item2}.AssertAreEqual(output.Select(x => x.Item1));

new[]{item1, item2}.AssertAreEqual(before_output.Select(x => x.Item1));

new[]{"IsOnlyOneWord", "IsNotNullString"}.AssertAreEqual(output.Select(x => x.Item2));

}

[Fact]

public void ChangeTrackingShouldWorkWhenAddingTheSameThingMoreThanOnce()

{

var fixture = new ReactiveList<TestFixture>() { ChangeTrackingEnabled = true };

var output = new List<Tuple<TestFixture, string>>();

var item1 = new TestFixture() { IsOnlyOneWord = "Foo" };

fixture.ItemChanged.Subscribe(x => {

output.Add(new Tuple<TestFixture,string>((TestFixture)x.Sender, x.PropertyName));

});

fixture.Add(item1);

fixture.Add(item1);

fixture.Add(item1);

item1.IsOnlyOneWord = "Bar";

Assert.Equal(1, output.Count);

fixture.RemoveAt(0);

item1.IsOnlyOneWord = "Baz";

Assert.Equal(2, output.Count);

fixture.RemoveAt(0);

fixture.RemoveAt(0);

// We've completely removed item1, we shouldn't be seeing any

// notifications from it

item1.IsOnlyOneWord = "Bamf";

Assert.Equal(2, output.Count);

fixture.ChangeTrackingEnabled = false;

fixture.Add(item1);

fixture.Add(item1);

fixture.Add(item1);

fixture.ChangeTrackingEnabled = true;

item1.IsOnlyOneWord = "Bonk";

Assert.Equal(3, output.Count);

}

[Fact]

public void ChangeTrackingItemsShouldBeTrackedEvenWhenSuppressed()

{

var input = new TestFixture();

var fixture = new ReactiveList<TestFixture>() { ChangeTrackingEnabled = true };

var changes = fixture.ItemChanged.CreateCollection();

Assert.Equal(0, changes.Count);

input.IsOnlyOneWord = "foo";

Assert.Equal(0, changes.Count);

using (fixture.SuppressChangeNotifications()) {

fixture.Add(input);

input.IsOnlyOneWord = "bar";

Assert.Equal(0, changes.Count);

}

// Even though we added it during a suppression, we should still

// get notifications now that the suppression is over

input.IsOnlyOneWord = "baz";

Assert.Equal(1, changes.Count);

fixture.RemoveAt(0);

input.IsOnlyOneWord = "bamf";

Assert.Equal(1, changes.Count);

}

[Fact]

public void ChangeTrackingShouldApplyOnAddRangedItems()

{

var fixture = new ReactiveList<TestFixture>() { new TestFixture() };

fixture.ChangeTrackingEnabled = true;

var reset = fixture.ShouldReset.CreateCollection();

var itemChanged = fixture.ItemChanged.CreateCollection();

Assert.Equal(0, reset.Count);

fixture[0].IsNotNullString = "Foo";

Assert.Equal(0, reset.Count);

Assert.Equal(1, itemChanged.Count);

fixture.AddRange(Enumerable.Range(0, 15).Select(x => new TestFixture() { IsOnlyOneWord = x.ToString() }));

Assert.Equal(1, reset.Count);

Assert.Equal(1, itemChanged.Count);

fixture[0].IsNotNullString = "Bar";

Assert.Equal(1, reset.Count);

Assert.Equal(2, itemChanged.Count);

fixture[5].IsNotNullString = "Baz";

Assert.Equal(1, reset.Count);

Assert.Equal(3, itemChanged.Count);

}

[Fact]

public void ChangeTrackingShouldStopWhenAnObjectIsReplacedAndChangeNotificationIsSurpressed()

{

var fixture = new ReactiveList<TestFixture>() { ChangeTrackingEnabled = true };

var before_output = new List<Tuple<TestFixture, string>>();

var output = new List<Tuple<TestFixture, string>>();

var item1 = new TestFixture() { IsOnlyOneWord = "Foo" };

var item2 = new TestFixture() { IsOnlyOneWord = "Bar" };

fixture.ItemChanging.Subscribe(x =>

{

before_output.Add(new Tuple<TestFixture, string>((TestFixture)x.Sender, x.PropertyName));

});

fixture.ItemChanged.Subscribe(x =>

{

output.Add(new Tuple<TestFixture, string>((TestFixture)x.Sender, x.PropertyName));

});

fixture.Add(item1);

item1.IsOnlyOneWord = "Baz";

Assert.Equal(1, output.Count);

item2.IsNotNullString = "FooBar";

Assert.Equal(1, output.Count);

using (var subscription = fixture.suppressChangeNotifications())

{

fixture[0] = item2;

}

item1.IsOnlyOneWord = "FooAgain";

Assert.Equal(1, output.Count);

item2.IsNotNullString = "FooBarBaz";

Assert.Equal(2, output.Count);

new[] { item1, item2 }.AssertAreEqual(output.Select(x => x.Item1));

new[] { item1, item2 }.AssertAreEqual(before_output.Select(x => x.Item1));

new[] { "IsOnlyOneWord", "IsNotNullString" }.AssertAreEqual(output.Select(x => x.Item2));

}

[Fact]

public void GetAResetWhenWeAddALotOfItems()

{

var fixture = new ReactiveList<int> { 1, };

var reset = fixture.ShouldReset.CreateCollection();

Assert.Equal(0, reset.Count);

fixture.AddRange(new[] { 2,3,4,5,6,7,8,9,10,11,12,13, });

Assert.Equal(1, reset.Count);

}

[Fact]

public void GetARangeWhenWeAddAListOfItems()

{

var fixture = new ReactiveList<int> { 1, 2, 3, 4, 5 };

var changed = fixture.Changed.CreateCollection();

Assert.Equal(0, changed.Count);

fixture.AddRange(new[] { 6, 7 });

Assert.Equal(1, changed.Count);

Assert.Equal(NotifyCollectionChangedAction.Add, changed.First().Action);

}

[Fact]

public void GetSingleItemNotificationWhenWeAddAListOfItemsAndRangeIsFalse()

{

try {

RxApp.SupportsRangeNotifications = false;

var fixture = new ReactiveList<int> { 1, 2, 3, 4, 5 };

var changed = fixture.Changed.CreateCollection();

Assert.Equal(0, changed.Count);

fixture.AddRange(new[] { 6, 7 });

Assert.Equal(2, changed.Count);

Assert.Equal(NotifyCollectionChangedAction.Add, changed[0].Action);

Assert.Equal(NotifyCollectionChangedAction.Add, changed[1].Action);

} finally {

RxApp.SupportsRangeNotifications = true;

}

}

[Fact]

public void CollectionsShouldntShareSubscriptions()

{

var fixture1 = new ReactiveList<TestFixture>() { ChangeTrackingEnabled = true };

var fixture2 = new ReactiveList<TestFixture>() { ChangeTrackingEnabled = true };

var item1 = new TestFixture() { IsOnlyOneWord = "Foo" };

var output1 = new List<Tuple<TestFixture, string>>();

var output2 = new List<Tuple<TestFixture, string>>();

fixture1.ItemChanged.Subscribe(x => {

output1.Add(new Tuple<TestFixture,string>((TestFixture)x.Sender, x.PropertyName));

});

fixture2.ItemChanged.Subscribe(x => {

output2.Add(new Tuple<TestFixture,string>((TestFixture)x.Sender, x.PropertyName));

});

fixture1.Add(item1);

fixture1.Add(item1);

fixture2.Add(item1);

fixture2.Add(item1);

item1.IsOnlyOneWord = "Bar";

Assert.Equal(1, output1.Count);

Assert.Equal(1, output2.Count);

fixture2.RemoveAt(0);

item1.IsOnlyOneWord = "Baz";

Assert.Equal(2, output1.Count);

Assert.Equal(2, output2.Count);

}

[Fact]

public void CreateCollectionWithoutTimer()

{

var input = new[] {"Foo", "Bar", "Baz", "Bamf"};

var fixture = (new TestScheduler()).With(sched => {

var f = input.ToObservable(sched).CreateCollection();

sched.Start();

return f;

});

input.AssertAreEqual(fixture);

}

[Fact]

public void CreateCollectionWithTimer()

{

var input = new[] {"Foo", "Bar", "Baz", "Bamf"};

var sched = new TestScheduler();

using (TestUtils.WithScheduler(sched)) {

IReactiveDerivedList<string> fixture;

fixture = input.ToObservable(sched).CreateCollection(TimeSpan.FromSeconds(0.5));

sched.AdvanceToMs(1005);

fixture.AssertAreEqual(input.Take(2));

sched.AdvanceToMs(1505);

fixture.AssertAreEqual(input.Take(3));

sched.AdvanceToMs(10000);

fixture.AssertAreEqual(input);

}

}

[Fact]

public void DerivedCollectionsShouldFollowBaseCollection()

{

var input = new[] {"Foo", "Bar", "Baz", "Bamf"};

var fixture = new ReactiveList<TestFixture>(

input.Select(x => new TestFixture() { IsOnlyOneWord = x }));

var output = fixture.CreateDerivedCollection(new Func<TestFixture, string>(x => x.IsOnlyOneWord));

input.AssertAreEqual(output);

fixture.Add(new TestFixture() { IsOnlyOneWord = "Hello" });

Assert.Equal(5, output.Count);

Assert.Equal("Hello", output[4]);

fixture.RemoveAt(4);

Assert.Equal(4, output.Count);

fixture[1] = new TestFixture() { IsOnlyOneWord = "Goodbye" };

Assert.Equal(4, output.Count);

Assert.Equal("Goodbye", output[1]);

fixture.Clear();

Assert.Equal(0, output.Count);

}

[Fact]

public void DerivedCollectionsShouldBeFiltered()

{

var input = new[] {"Foo", "Bar", "Baz", "Bamf"};

var fixture = new ReactiveList<TestFixture>(

input.Select(x => new TestFixture() { IsOnlyOneWord = x }));

var itemsAdded = new List<TestFixture>();

var itemsRemoved = new List<TestFixture>();

var output = fixture.CreateDerivedCollection(x => x, x => x.IsOnlyOneWord[0] == 'F', (l,r) => l.IsOnlyOneWord.CompareTo(r.IsOnlyOneWord));

output.ItemsAdded.Subscribe(itemsAdded.Add);

output.ItemsRemoved.Subscribe(itemsRemoved.Add);

Assert.Equal(1, output.Count);

Assert.Equal(0, itemsAdded.Count);

Assert.Equal(0, itemsRemoved.Count);

fixture.Add(new TestFixture() {IsOnlyOneWord = "Boof"});

Assert.Equal(1, output.Count);

Assert.Equal(0, itemsAdded.Count);

Assert.Equal(0, itemsRemoved.Count);

fixture.Add(new TestFixture() {IsOnlyOneWord = "Far"});

Assert.Equal(2, output.Count);

Assert.Equal(1, itemsAdded.Count);

Assert.Equal(0, itemsRemoved.Count);

fixture.RemoveAt(1); // Remove "Bar"

Assert.Equal(2, output.Count);

Assert.Equal(1, itemsAdded.Count);

Assert.Equal(0, itemsRemoved.Count);

fixture.RemoveAt(0); // Remove "Foo"

Assert.Equal(1, output.Count);

Assert.Equal(1, itemsAdded.Count);

Assert.Equal(1, itemsRemoved.Count);

}

[Fact]

public void DerivedCollectionShouldBeSorted()

{

var input = new[] { "Foo", "Bar", "Baz" };

var fixture = new ReactiveList<string>(input);

var output = fixture.CreateDerivedCollection(x => x, orderer: String.CompareOrdinal);

Assert.Equal(3, output.Count);

Assert.True(new[] { "Bar", "Baz", "Foo" }.Zip(output, (expected, actual) => expected == actual).All(x => x));

fixture.Add("Bamf");

Assert.Equal(4, output.Count);

Assert.True(new[] { "Bamf", "Bar", "Baz", "Foo" }.Zip(output, (expected, actual) => expected == actual).All(x => x));

fixture.Add("Eoo");

Assert.Equal(5, output.Count);

Assert.True(new[] { "Bamf", "Bar", "Baz", "Eoo", "Foo" }.Zip(output, (expected, actual) => expected == actual).All(x => x));

fixture.Add("Roo");

Assert.Equal(6, output.Count);

Assert.True(new[] { "Bamf", "Bar", "Baz", "Eoo", "Foo", "Roo" }.Zip(output, (expected, actual) => expected == actual).All(x => x));

fixture.Add("Bar");

Assert.Equal(7, output.Count);

Assert.True(new[] { "Bamf", "Bar", "Bar", "Baz", "Eoo", "Foo", "Roo" }.Zip(output, (expected, actual) => expected == actual).All(x => x));

}

[Fact]

public void DerivedCollectionSignalledToResetShouldFireExactlyOnce()

{

var input = new List<string> { "Foo" };

var resetSubject = new Subject<Unit>();

var derived = input.CreateDerivedCollection(x => x, signalReset: resetSubject);

var changeNotifications = new List<NotifyCollectionChangedEventArgs>();

derived.Changed.Subscribe(changeNotifications.Add);

Assert.Equal(0, changeNotifications.Count);

Assert.Equal(1, derived.Count);

input.Add("Bar");

// Shouldn't have picked anything up since the input isn't reactive

Assert.Equal(0, changeNotifications.Count);

Assert.Equal(1, derived.Count);

resetSubject.OnNext(Unit.Default);

Assert.Equal(1, changeNotifications.Count);

Assert.Equal(2, derived.Count);

}

#if !SILVERLIGHT

[Fact]

public void DerivedCollectionMoveNotificationSmokeTest()

{

var initial = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

var source = new ReactiveList<int>(initial);

var derived = source.CreateDerivedCollection(x => x);

var nestedDerived = derived.CreateDerivedCollection(x => x);

var derivedSorted = source.CreateDerivedCollection(x => x, orderer: (x, y) => x.CompareTo(y));

for (int i = 0; i < initial.Length; i++) {

for (int j = 0; j < initial.Length; j++) {

source.Move(i, j);

Assert.True(derived.SequenceEqual(source));

Assert.True(nestedDerived.SequenceEqual(source));

Assert.True(derivedSorted.SequenceEqual(initial));

}

}

}

#endif

#if !SILVERLIGHT

[Fact]

public void DerivedCollectionShouldUnderstandMoveSignals()

{

var source = new System.Collections.ObjectModel.ObservableCollection<string> {

"a", "b", "c", "d", "e", "f"

};

var derived = source.CreateDerivedCollection(x => x);

var sourceNotifications = new List<NotifyCollectionChangedEventArgs>();

Observable.FromEventPattern<NotifyCollectionChangedEventHandler, NotifyCollectionChangedEventArgs>(

x => source.CollectionChanged += x,

x => source.CollectionChanged -= x

).Subscribe(x => sourceNotifications.Add(x.EventArgs));

var derivedNotifications = new List<NotifyCollectionChangedEventArgs>();

derived.Changed.Subscribe(derivedNotifications.Add);

Assert.Equal(6, derived.Count);

Assert.True(source.SequenceEqual(derived));

Assert.Empty(derivedNotifications);

source.Move(1, 4);

Assert.True(source.SequenceEqual(new[] { "a", "c", "d", "e", "b", "f" }));

Assert.True(derived.SequenceEqual(source));

Assert.Equal(1, sourceNotifications.Count);

Assert.Equal(NotifyCollectionChangedAction.Move, sourceNotifications.First().Action);

Assert.Equal(1, derivedNotifications.Count);

Assert.Equal(NotifyCollectionChangedAction.Move, derivedNotifications.First().Action);

sourceNotifications.Clear();

derivedNotifications.Clear();

source.Move(4, 1);

Assert.True(source.SequenceEqual(new[] { "a", "b", "c", "d", "e", "f" }));

Assert.True(derived.SequenceEqual(source));

Assert.Equal(1, sourceNotifications.Count);

Assert.Equal(NotifyCollectionChangedAction.Move, sourceNotifications.First().Action);

Assert.Equal(1, derivedNotifications.Count);

Assert.Equal(NotifyCollectionChangedAction.Move, derivedNotifications.First().Action);

source.Move(0, 5);

Assert.True(source.SequenceEqual(new[] { "b", "c", "d", "e", "f", "a" }));

Assert.True(derived.SequenceEqual(source));

source.Move(5, 0);

Assert.True(source.SequenceEqual(new[] { "a", "b", "c", "d", "e", "f", }));

Assert.True(derived.SequenceEqual(source));

}

#endif

#if !SILVERLIGHT

[Fact]

public void DerivedCollectionShouldUnderstandNestedMoveSignals()

{

var source = new System.Collections.ObjectModel.ObservableCollection<string> {

"a", "b", "c", "d", "e", "f"

};

var derived = source.CreateDerivedCollection(x => x);

var nested = derived.CreateDerivedCollection(x => x);

var reverseNested = nested.CreateDerivedCollection(

x => x,

orderer: OrderedComparer<string>.OrderByDescending(x => x).Compare

);

var sortedNested = reverseNested.CreateDerivedCollection(

x => x,

orderer: OrderedComparer<string>.OrderBy(x => x).Compare

);

source.Move(1, 4);

Assert.True(source.SequenceEqual(derived));

Assert.True(source.SequenceEqual(nested));

Assert.True(source.OrderByDescending(x => x).SequenceEqual(reverseNested));

Assert.True(source.OrderBy(x => x).SequenceEqual(sortedNested));

}

#endif

#if !SILVERLIGHT

[Fact]

public void DerivedCollectionShouldUnderstandMoveEvenWhenSorted()

{

var sanity = new List<string> { "a", "b", "c", "d", "e", "f" };

var source = new System.Collections.ObjectModel.ObservableCollection<string> {

"a", "b", "c", "d", "e", "f"

};

var derived = source.CreateDerivedCollection(

selector: x => x,

filter: x => x != "c",

orderer: (x, y) => x.CompareTo(y)

);

var sourceNotifications = new List<NotifyCollectionChangedEventArgs>();

Observable.FromEventPattern<NotifyCollectionChangedEventHandler, NotifyCollectionChangedEventArgs>(

x => source.CollectionChanged += x,

x => source.CollectionChanged -= x

).Subscribe(x => sourceNotifications.Add(x.EventArgs));

var derivedNotifications = new List<NotifyCollectionChangedEventArgs>();

derived.Changed.Subscribe(derivedNotifications.Add);

Assert.Equal(5, derived.Count);

Assert.True(derived.SequenceEqual(new[] { "a", "b" /*, "c" */, "d", "e", "f" }));

var rnd = new Random();

for (int i = 0; i < 50; i++) {

int from = rnd.Next(0, source.Count);

int to;

do { to = rnd.Next(0, source.Count); } while (to == from);

source.Move(from, to);

string tmp = sanity[from];

sanity.RemoveAt(from);

sanity.Insert(to, tmp);

Assert.True(source.SequenceEqual(sanity));

Assert.True(derived.SequenceEqual(new[] { "a", "b" /*, "c" */, "d", "e", "f" }));

Assert.Equal(1, sourceNotifications.Count);

Assert.Equal(NotifyCollectionChangedAction.Move, sourceNotifications.First().Action);

Assert.Empty(derivedNotifications);

sourceNotifications.Clear();

}

}

#endif

#if !SILVERLIGHT

[Fact]

public void DerivedCollectionShouldUnderstandDummyMoveSignal()

{

var sanity = new List<string> { "a", "b", "c", "d", "e", "f" };

var source = new System.Collections.ObjectModel.ObservableCollection<string> {

"a", "b", "c", "d", "e", "f"

};

var derived = source.CreateDerivedCollection(x => x);

var sourceNotifications = new List<NotifyCollectionChangedEventArgs>();

Observable.FromEventPattern<NotifyCollectionChangedEventHandler, NotifyCollectionChangedEventArgs>(

x => source.CollectionChanged += x,

x => source.CollectionChanged -= x

).Subscribe(x => sourceNotifications.Add(x.EventArgs));

var derivedNotification = new List<NotifyCollectionChangedEventArgs>();

derived.Changed.Subscribe(derivedNotification.Add);

source.Move(0, 0);

Assert.Equal(1, sourceNotifications.Count);

Assert.Equal(NotifyCollectionChangedAction.Move, sourceNotifications.First().Action);

Assert.Equal(0, derivedNotification.Count);

}

#endif

#if !SILVERLIGHT

[Fact]

public void DerivedCollectionShouldNotSignalRedundantMoveSignals()

{

var sanity = new List<string> { "a", "b", "c", "d", "e", "f" };

var source = new System.Collections.ObjectModel.ObservableCollection<string> {

"a", "b", "c", "d", "e", "f"

};

var derived = source.CreateDerivedCollection(x => x, x => x == "d" || x == "e");

var derivedNotification = new List<NotifyCollectionChangedEventArgs>();

derived.Changed.Subscribe(derivedNotification.Add);

Assert.Equal("d", source[3]);

source.Move(3, 0);

Assert.Equal(0, derivedNotification.Count);

}

#endif

#if !SILVERLIGHT

[Fact]

public void DerivedCollectionShouldHandleMovesWhenOnlyContainingOneItem()

{

// This test is here to verify a bug in where newPositionForItem would return an incorrect

// index for lists only containing a single item (the item to find a new position for)

var sanity = new List<string> { "a", "b", "c", "d", "e", "f" };

var source = new System.Collections.ObjectModel.ObservableCollection<string> {

"a", "b", "c", "d", "e", "f"

};

var derived = source.CreateDerivedCollection(x => x, x => x == "d");

Assert.Equal("d", derived.Single());

Assert.Equal("d", source[3]);

source.Move(3, 0);

Assert.Equal("d", source[0]);

Assert.Equal("d", derived.Single());

}

#endif

/// <summary>

/// This test is a bit contrived and only exists to verify that a particularly gnarly bug doesn't get

/// reintroduced because it's hard to reason about the removal logic in derived collections and it might

/// be tempting to try and reorder the shiftIndices operation in there.

/// </summary>

[Fact]

public void DerivedCollectionRemovalRegressionTest()

{

var input = new[] { 'A', 'B', 'C', 'D' };

var source = new ReactiveList<char>(input);

// A derived collection that filters away 'A' and 'B'

var derived = source.CreateDerivedCollection(x => x, x=> x >= 'C');

var changeNotifications = new List<NotifyCollectionChangedEventArgs>();

derived.Changed.Subscribe(changeNotifications.Add);

Assert.Equal(0, changeNotifications.Count);

Assert.Equal(2, derived.Count);

Assert.True(derived.SequenceEqual(new [] { 'C', 'D' }));

// The tricky part here is that 'B' isn't in the derived collection, only 'C' is and this test

// will detect if the dervied collection gets tripped up and removes 'C' instead

source.RemoveAll(new[] { 'B', 'C' });

Assert.Equal(1, changeNotifications.Count);

Assert.Equal(1, derived.Count);

Assert.True(derived.SequenceEqual(new[] { 'D' }));

}

[Fact]

public void DerviedCollectionShouldHandleItemsRemoved()

{

var input = new[] { "Foo", "Bar", "Baz", "Bamf" };

var disposed = new List<TestFixture>();

var fixture = new ReactiveList<TestFixture>(

input.Select(x => new TestFixture() { IsOnlyOneWord = x }));

var output = fixture.CreateDerivedCollection(x => Disposable.Create(() => disposed.Add(x)), item => item.Dispose());

fixture.Add(new TestFixture() { IsOnlyOneWord = "Hello" });

Assert.Equal(5, output.Count);

fixture.RemoveAt(3);

Assert.Equal(4, output.Count);

Assert.Equal(1, disposed.Count);

Assert.Equal("Bamf", disposed[0].IsOnlyOneWord);

fixture[1] = new TestFixture() { IsOnlyOneWord = "Goodbye" };

Assert.Equal(4, output.Count);

Assert.Equal(2, disposed.Count);

Assert.Equal("Bar", disposed[1].IsOnlyOneWord);

var count = output.Count;

output.Dispose();

Assert.Equal(disposed.Count, 2 + count);

}

public class DerivedCollectionLogging

{

// We need a sentinel class to make sure no test has triggered the warnings before

class NoOneHasEverSeenThisClassBefore

{

}

class NoOneHasEverSeenThisClassBeforeEither

{

}