Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

external/rx/Rx/NET/Source/Tests.System.Reactive/Tests/Linq/ObservableAggregateTest.cs.REMOVED.git-id

@@ -0,0 +1 @@
+c69501edcdadc70106dd8960d1d35049d37b3d32

external/rx/Rx/NET/Source/Tests.System.Reactive/Tests/Linq/ObservableAsyncTest.cs.REMOVED.git-id

@@ -0,0 +1 @@
+be19f563bcddb129ae222c37216715e0e0a10575

external/rx/Rx/NET/Source/Tests.System.Reactive/Tests/Linq/ObservableAwaiterTest.cs

@@ -0,0 +1,152 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if HAS_AWAIT
+
+using System;
+using System.Collections.Generic;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using Microsoft.Reactive.Testing;
+#if NUNIT
+using NUnit.Framework;
+using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
+using TestMethodAttribute = NUnit.Framework.TestAttribute;
+using TestInitializeAttribute = NUnit.Framework.SetUpAttribute;
+#else
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+#endif
+using ReactiveTests.Dummies;
+
+namespace ReactiveTests.Tests
+{
+    [TestClass]
+    public class ObservableAwaiterTest : ReactiveTest
+    {
+        [TestMethod]
+        public void Await_ArgumentChecking()
+        {
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.GetAwaiter<int>(null));
+            ReactiveAssert.Throws<ArgumentNullException>(() => Observable.GetAwaiter(Observable.Empty<int>()).OnCompleted(null));
+        }
+
+        [TestMethod]
+        public void Await()
+        {
+            var scheduler = new TestScheduler();
+
+            var xs = scheduler.CreateHotObservable(
+                OnNext(20, -1),
+                OnNext(150, 0),
+                OnNext(220, 1),
+                OnNext(290, 2),
+                OnNext(340, 3),
+                OnCompleted<int>(410)
+            );
+
+            var awaiter = default(AsyncSubject<int>);
+            var result = default(int);
+            var t = long.MaxValue;
+
+            scheduler.ScheduleAbsolute(100, () => awaiter = xs.GetAwaiter());
+            scheduler.ScheduleAbsolute(200, () => awaiter.OnCompleted(() => { t = scheduler.Clock; result = awaiter.GetResult(); }));
+
+            scheduler.Start();
+
+            Assert.AreEqual(410, t);
+            Assert.AreEqual(3, result);
+
+            xs.Subscriptions.AssertEqual(
+                Subscribe(100)
+            );
+        }
+
+        [TestMethod]
+        public void Await_Error()
+        {
+            var scheduler = new TestScheduler();
+
+            var ex = new Exception();
+
+            var xs = scheduler.CreateHotObservable(
+                OnNext(20, -1),
+                OnNext(150, 0),
+                OnNext(220, 1),
+                OnNext(290, 2),
+                OnNext(340, 3),
+                OnError<int>(410, ex)
+            );
+
+            var awaiter = default(AsyncSubject<int>);
+            var t = long.MaxValue;
+
+            scheduler.ScheduleAbsolute(100, () => awaiter = xs.GetAwaiter());
+            scheduler.ScheduleAbsolute(200, () => awaiter.OnCompleted(() => { t = scheduler.Clock; ReactiveAssert.Throws(ex, () => awaiter.GetResult()); }));
+
+            scheduler.Start();
+
+            Assert.AreEqual(410, t);
+
+            xs.Subscriptions.AssertEqual(
+                Subscribe(100)
+            );
+        }
+
+        [TestMethod]
+        public void Await_Never()
+        {
+            var scheduler = new TestScheduler();
+
+            var xs = scheduler.CreateHotObservable(
+                OnNext(20, -1),
+                OnNext(150, 0),
+                OnNext(220, 1),
+                OnNext(290, 2),
+                OnNext(340, 3)
+            );
+
+            var awaiter = default(AsyncSubject<int>);
+            var hasValue = default(bool);
+            var t = long.MaxValue;
+
+            scheduler.ScheduleAbsolute(100, () => awaiter = xs.GetAwaiter());
+            scheduler.ScheduleAbsolute(200, () => awaiter.OnCompleted(() => { t = scheduler.Clock; awaiter.GetResult(); hasValue = true; }));
+
+            scheduler.Start();
+
+            Assert.AreEqual(long.MaxValue, t);
+            Assert.IsFalse(hasValue);
+
+            xs.Subscriptions.AssertEqual(
+                Subscribe(100)
+            );
+        }
+
+        [TestMethod]
+        public void Await_Empty()
+        {
+            var scheduler = new TestScheduler();
+
+            var xs = scheduler.CreateHotObservable(
+                OnCompleted<int>(300)
+            );
+
+            var awaiter = default(AsyncSubject<int>);
+            var t = long.MaxValue;
+
+            scheduler.ScheduleAbsolute(100, () => awaiter = xs.GetAwaiter());
+            scheduler.ScheduleAbsolute(200, () => awaiter.OnCompleted(() => { t = scheduler.Clock; ReactiveAssert.Throws<InvalidOperationException>(() => awaiter.GetResult()); }));
+
+            scheduler.Start();
+
+            Assert.AreEqual(300, t);
+
+            xs.Subscriptions.AssertEqual(
+                Subscribe(100)
+            );
+        }
+    }
+}
+
+#endif

external/rx/Rx/NET/Source/Tests.System.Reactive/Tests/Linq/ObservableExtensionsTest.cs

@@ -0,0 +1,399 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Threading;
+using Microsoft.Reactive.Testing;
+#if NUNIT
+using NUnit.Framework;
+using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
+using TestMethodAttribute = NUnit.Framework.TestAttribute;
+using TestInitializeAttribute = NUnit.Framework.SetUpAttribute;
+#else
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+#endif
+using System.Collections.Generic;
+
+namespace ReactiveTests.Tests
+{
+    [TestClass]
+    public partial class ObservableExtensionsTest : ReactiveTest
+    {
+        #region Subscribe
+
+        [TestMethod]
+        public void Subscribe_ArgumentChecking()
+        {
+            var someObservable = Observable.Empty<int>();
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default(IObservable<int>)));
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default(IObservable<int>), _ => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default(Action<int>)));
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default(IObservable<int>), _ => { }, () => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default(Action<int>), () => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, default(Action)));
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default(IObservable<int>), _ => { }, (Exception _) => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default(Action<int>), (Exception _) => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, default(Action<Exception>)));
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default(IObservable<int>), _ => { }, (Exception _) => { }, () => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default(Action<int>), (Exception _) => { }, () => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, default(Action<Exception>), () => { }));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, (Exception _) => { }, default(Action)));
+        }
+
+        [TestMethod]
+        public void Subscribe_None_Return()
+        {
+            Observable.Return(1, Scheduler.Immediate).Subscribe();
+        }
+
+        [TestMethod]
+        public void Subscribe_None_Throw()
+        {
+            var ex = new Exception();
+
+            var xs = Observable.Throw<int>(ex, Scheduler.Immediate);
+
+            ReactiveAssert.Throws(ex, () => xs.Subscribe());
+        }
+
+        [TestMethod]
+        public void Subscribe_None_Empty()
+        {
+            Observable.Empty<int>(Scheduler.Immediate).Subscribe((int _) => { Assert.Fail(); });
+        }
+
+        [TestMethod]
+        public void Subscribe_OnNext_Return()
+        {
+            int _x = -1;
+            Observable.Return(42, Scheduler.Immediate).Subscribe((int x) => { _x = x; });
+            Assert.AreEqual(42, _x);
+        }
+
+        [TestMethod]
+        public void Subscribe_OnNext_Throw()
+        {
+            var ex = new Exception();
+
+            var xs = Observable.Throw<int>(ex, Scheduler.Immediate);
+
+            ReactiveAssert.Throws(ex, () => xs.Subscribe(_ => { Assert.Fail(); }));
+        }
+
+        [TestMethod]
+        public void Subscribe_OnNext_Empty()
+        {
+            Observable.Empty<int>(Scheduler.Immediate).Subscribe((int _) => { Assert.Fail(); });
+        }
+
+        [TestMethod]
+        public void Subscribe_OnNextOnCompleted_Return()
+        {
+            bool finished = false;
+            int _x = -1;
+            Observable.Return(42, Scheduler.Immediate).Subscribe((int x) => { _x = x; }, () => { finished = true; });
+            Assert.AreEqual(42, _x);
+            Assert.IsTrue(finished);
+        }
+
+        [TestMethod]
+        public void Subscribe_OnNextOnCompleted_Throw()
+        {
+            var ex = new Exception();
+
+            var xs = Observable.Throw<int>(ex, Scheduler.Immediate);
+
+            ReactiveAssert.Throws(ex, () => xs.Subscribe(_ => { Assert.Fail(); }, () => { Assert.Fail(); }));
+        }
+
+        [TestMethod]
+        public void Subscribe_OnNextOnCompleted_Empty()
+        {
+            bool finished = false;
+            Observable.Empty<int>(Scheduler.Immediate).Subscribe((int _) => { Assert.Fail(); }, () => { finished = true; });
+            Assert.IsTrue(finished);
+        }
+
+        #endregion
+
+        #region Subscribe with CancellationToken
+
+#if !NO_TPL
+
+        [TestMethod]
+        public void Subscribe_CT_ArgumentChecking()
+        {
+            var someObservable = Observable.Empty<int>();
+            var someObserver = Observer.Create<int>(_ => { });
+            var ct = CancellationToken.None;
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default(IObservable<int>), someObserver, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default(IObserver<int>), ct));
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default(IObservable<int>), ct));
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default(IObservable<int>), _ => { }, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default(Action<int>), ct));
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default(IObservable<int>), _ => { }, () => { }, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default(Action<int>), () => { }, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, default(Action), ct));
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default(IObservable<int>), _ => { }, (Exception _) => { }, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default(Action<int>), (Exception _) => { }, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, default(Action<Exception>), ct));
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(default(IObservable<int>), _ => { }, (Exception _) => { }, () => { }, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, default(Action<int>), (Exception _) => { }, () => { }, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, default(Action<Exception>), () => { }, ct));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.Subscribe<int>(someObservable, _ => { }, (Exception _) => { }, default(Action), ct));
+        }
+
+        [TestMethod]
+        public void Subscribe_CT_None()
+        {
+            var scheduler = new TestScheduler();
+
+            var xs = scheduler.CreateHotObservable(
+                OnNext(210, 1),
+                OnNext(220, 2),
+                OnNext(230, 3),
+                OnCompleted<int>(240)
+            );
+
+            var obs = scheduler.CreateObserver<int>();
+
+            scheduler.ScheduleAbsolute(200, () => xs.Subscribe(obs, CancellationToken.None));
+
+            scheduler.Start();
+
+            obs.Messages.AssertEqual(
+                OnNext(210, 1),
+                OnNext(220, 2),
+                OnNext(230, 3),
+                OnCompleted<int>(240)
+            );
+
+            xs.Subscriptions.AssertEqual(
+                Subscribe(200, Subscription.Infinite /* no auto-dispose when using CreateHotObservable */)
+            );
+        }
+
+        [TestMethod]
+        public void Subscribe_CT_CancelBeforeBegin()
+        {
+            var scheduler = new TestScheduler();
+
+            var xs = scheduler.CreateHotObservable(
+                OnNext(210, 1),
+                OnNext(220, 2),
+                OnNext(230, 3),
+                OnCompleted<int>(240)
+            );
+
+            var cts = new CancellationTokenSource();
+
+            var obs = scheduler.CreateObserver<int>();
+
+            scheduler.ScheduleAbsolute(200, () => xs.Subscribe(obs, cts.Token));
+            scheduler.ScheduleAbsolute(150, cts.Cancel);
+
+            scheduler.Start();
+
+            obs.Messages.AssertEqual(
+            );
+
+            xs.Subscriptions.AssertEqual(
+            );
+        }
+
+        [TestMethod]
+        public void Subscribe_CT_CancelMiddle()
+        {
+            var scheduler = new TestScheduler();
+
+            var xs = scheduler.CreateHotObservable(
+                OnNext(210, 1),
+                OnNext(220, 2),
+                OnNext(230, 3),
+                OnCompleted<int>(240)
+            );
+
+            var cts = new CancellationTokenSource();
+
+            var obs = scheduler.CreateObserver<int>();
+
+            scheduler.ScheduleAbsolute(200, () => xs.Subscribe(obs, cts.Token));
+            scheduler.ScheduleAbsolute(225, cts.Cancel);
+
+            scheduler.Start();
+
+            obs.Messages.AssertEqual(
+                OnNext(210, 1),
+                OnNext(220, 2)
+            );
+
+            xs.Subscriptions.AssertEqual(
+                Subscribe(200, 225)
+            );
+        }
+
+        [TestMethod]
+        public void Subscribe_CT_CancelAfterEnd()
+        {
+            var scheduler = new TestScheduler();
+
+            var ex = new Exception();
+
+            var xs = scheduler.CreateHotObservable(
+                OnNext(210, 1),
+                OnNext(220, 2),
+                OnNext(230, 3),
+                OnError<int>(240, ex)
+            );
+
+            var cts = new CancellationTokenSource();
+
+            var obs = scheduler.CreateObserver<int>();
+
+            scheduler.ScheduleAbsolute(200, () => xs.Subscribe(obs, cts.Token));
+            scheduler.ScheduleAbsolute(250, cts.Cancel);
+
+            scheduler.Start();
+
+            obs.Messages.AssertEqual(
+                OnNext(210, 1),
+                OnNext(220, 2),
+                OnNext(230, 3),
+                OnError<int>(240, ex)
+            );
+
+            xs.Subscriptions.AssertEqual(
+                Subscribe(200, Subscription.Infinite /* no auto-dispose when using CreateHotObservable */)
+            );
+        }
+
+        [TestMethod]
+        public void Subscribe_CT_NeverCancel()
+        {
+            var scheduler = new TestScheduler();
+
+            var xs = scheduler.CreateHotObservable(
+                OnNext(210, 1),
+                OnNext(220, 2),
+                OnNext(230, 3),
+                OnCompleted<int>(240)
+            );
+
+            var cts = new CancellationTokenSource();
+
+            var obs = scheduler.CreateObserver<int>();
+
+            scheduler.ScheduleAbsolute(200, () => xs.Subscribe(obs, cts.Token));
+
+            scheduler.Start();
+
+            obs.Messages.AssertEqual(
+                OnNext(210, 1),
+                OnNext(220, 2),
+                OnNext(230, 3),
+                OnCompleted<int>(240)
+            );
+
+            xs.Subscriptions.AssertEqual(
+                Subscribe(200, Subscription.Infinite /* no auto-dispose when using CreateHotObservable */)
+            );
+        }
+
+        [TestMethod]
+        public void Subscribe_CT_Overloads_AlreadyCancelled()
+        {
+            var xs = Observable.Defer<int>(() =>
+            {
+                Assert.Fail();
+                return Observable.Return(42, Scheduler.Immediate);
+            });
+
+            var cts = new CancellationTokenSource();
+            cts.Cancel();
+
+            xs.Subscribe(cts.Token);
+            xs.Subscribe(_ => { }, cts.Token);
+            xs.Subscribe(_ => { }, ex => { }, cts.Token);
+            xs.Subscribe(_ => { }, () => { }, cts.Token);
+            xs.Subscribe(_ => { }, ex => { }, () => { }, cts.Token);
+            xs.Subscribe(Observer.Create<int>(_ => { }, ex => { }, () => { }), cts.Token);
+        }
+
+        [TestMethod]
+        public void Subscribe_CT_Overloads_None()
+        {
+            var i = 0;
+            var n = 0;
+            var e = 0;
+            var c = 0;
+
+            var xs = Observable.Defer<int>(() =>
+            {
+                i++;
+                return Observable.Return(42, Scheduler.Immediate);
+            });
+
+            xs.Subscribe(CancellationToken.None);
+            xs.Subscribe(_ => { n++; }, CancellationToken.None);
+            xs.Subscribe(_ => { n++; }, ex => { e++; }, CancellationToken.None);
+            xs.Subscribe(_ => { n++; }, () => { c++; }, CancellationToken.None);
+            xs.Subscribe(_ => { n++; }, ex => { e++; }, () => { c++; }, CancellationToken.None);
+            xs.Subscribe(Observer.Create<int>(_ => { n++; }, ex => { e++; }, () => { c++; }), CancellationToken.None);
+
+            Assert.AreEqual(6, i);
+            Assert.AreEqual(5, n);
+            Assert.AreEqual(0, e);
+            Assert.AreEqual(3, c);
+        }
+
+        [TestMethod]
+        public void Subscribe_CT_CancelDuringCallback()
+        {
+            var scheduler = new TestScheduler();
+
+            var xs = scheduler.CreateHotObservable(
+                OnNext(210, 1),
+                OnNext(220, 2),
+                OnNext(230, 3),
+                OnCompleted<int>(240)
+            );
+
+            var cts = new CancellationTokenSource();
+
+            var n = 0;
+
+            scheduler.ScheduleAbsolute(200, () => xs.Subscribe(x =>
+            {
+                n++;
+
+                if (x == 2)
+                    cts.Cancel();
+            }, cts.Token));
+
+            scheduler.Start();
+
+            Assert.AreEqual(2, n);
+
+            xs.Subscriptions.AssertEqual(
+                Subscribe(200, 220)
+            );
+        }
+
+#endif
+
+        #endregion
+    }
+}

external/rx/Rx/NET/Source/Tests.System.Reactive/Tests/Linq/ObservableMultipleTest.cs.REMOVED.git-id

@@ -0,0 +1 @@
+bf289b1375fed392f0c03be550495fbabf4d638e

external/rx/Rx/NET/Source/Tests.System.Reactive/Tests/Linq/ObservableRemotingTest.cs

@@ -0,0 +1,229 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_REMOTING
+
+using System;
+using System.Reactive.Linq;
+using System.Reflection;
+using System.Runtime.Remoting.Lifetime;
+using System.Threading;
+using Microsoft.Reactive.Testing;
+#if NUNIT
+using NUnit.Framework;
+using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
+using TestMethodAttribute = NUnit.Framework.TestAttribute;
+using TestInitializeAttribute = NUnit.Framework.SetUpAttribute;
+#else
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+#endif
+
+namespace ReactiveTests.Tests
+{
+    [TestClass]
+    public partial class ObservableRemotingTest : ReactiveTest
+    {
+        [TestMethod]
+        public void Remotable_ArgumentChecking()
+        {
+            ReactiveAssert.Throws<ArgumentNullException>(() => RemotingObservable.Remotable(default(IObservable<int>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => RemotingObservable.Remotable(default(IObservable<int>), new MyLease()));
+
+            ReactiveAssert.Throws<ArgumentNullException>(() => RemotingObservable.Remotable(default(IQbservable<int>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => RemotingObservable.Remotable(default(IQbservable<int>), new MyLease()));
+
+            RemotingObservable.Remotable(Observable.Return(42));
+            RemotingObservable.Remotable(Observable.Return(42), null /* valid lease object */);
+
+#if !NO_REFLECTION_EMIT
+            RemotingObservable.Remotable(Qbservable.Return(Qbservable.Provider, 42));
+            RemotingObservable.Remotable(Qbservable.Return(Qbservable.Provider, 42), null /* valid lease object */);
+#endif
+        }
+
+        class MyLease : ILease
+        {
+            public TimeSpan CurrentLeaseTime
+            {
+                get { throw new NotImplementedException(); }
+            }
+
+            public LeaseState CurrentState
+            {
+                get { throw new NotImplementedException(); }
+            }
+
+            public TimeSpan InitialLeaseTime
+            {
+                get
+                {
+                    throw new NotImplementedException();
+                }
+                set
+                {
+                    throw new NotImplementedException();
+                }
+            }
+
+            public void Register(ISponsor obj)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Register(ISponsor obj, TimeSpan renewalTime)
+            {
+                throw new NotImplementedException();
+            }
+
+            public TimeSpan Renew(TimeSpan renewalTime)
+            {
+                throw new NotImplementedException();
+            }
+
+            public TimeSpan RenewOnCallTime
+            {
+                get
+                {
+                    throw new NotImplementedException();
+                }
+                set
+                {
+                    throw new NotImplementedException();
+                }
+            }
+
+            public TimeSpan SponsorshipTimeout
+            {
+                get
+                {
+                    throw new NotImplementedException();
+                }
+                set
+                {
+                    throw new NotImplementedException();
+                }
+            }
+
+            public void Unregister(ISponsor obj)
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        [TestMethod]
+        public void Remotable_Empty()
+        {
+            var evt = new ManualResetEvent(false);
+
+            var e = GetRemoteObservable(t => t.Empty());
+            using (e.Subscribe(_ => { Assert.Fail(); }, _ => { Assert.Fail(); }, () => { evt.Set(); }))
+            {
+                evt.WaitOne();
+            }
+        }
+
+        [TestMethod]
+        public void Remotable_Return()
+        {
+            var evt = new ManualResetEvent(false);
+
+            bool next = false;
+            var e = GetRemoteObservable(t => t.Return(42));
+            using (e.Subscribe(value => { next = true; Assert.AreEqual(42, value); }, _ => { Assert.Fail(); }, () => { evt.Set(); }))
+            {
+                evt.WaitOne();
+                Assert.IsTrue(next);
+            }
+        }
+
+        [TestMethod]
+        public void Remotable_Return_LongLease()
+        {
+            var evt = new ManualResetEvent(false);
+
+            bool next = false;
+            var e = GetRemoteObservable(t => t.ReturnLongLease(42));
+            using (e.Subscribe(value => { next = true; Assert.AreEqual(42, value); }, _ => { Assert.Fail(); }, () => { evt.Set(); }))
+            {
+                evt.WaitOne();
+                Assert.IsTrue(next);
+            }
+        }
+
+        [TestMethod]
+        public void Remotable_Throw()
+        {
+            var ex = new InvalidOperationException("Oops!");
+
+            var evt = new ManualResetEvent(false);
+
+            bool error = false;
+            var e = GetRemoteObservable(t => t.Throw(ex));
+            using (e.Subscribe(value => { Assert.Fail(); }, err => { error = true; Assert.IsTrue(err is InvalidOperationException && err.Message == ex.Message); evt.Set(); }, () => { Assert.Fail(); }))
+            {
+                evt.WaitOne();
+                Assert.IsTrue(error);
+            }
+        }
+
+        [TestMethod]
+        public void Remotable_Disposal()
+        {
+            var test = GetRemoteTestObject();
+            test.Disposal().Subscribe().Dispose();
+            Assert.IsTrue(test.Disposed);
+        }
+
+        private IObservable<int> GetRemoteObservable(Func<RemotingTest, IObservable<int>> f)
+        {
+            var test = GetRemoteTestObject();
+            return f(test);
+        }
+
+        private RemotingTest GetRemoteTestObject()
+        {
+            var ads = new AppDomainSetup { ApplicationBase = Utils.GetTestBaseDirectory() };
+            var ad = AppDomain.CreateDomain("test", null, ads);
+            var test = (RemotingTest)ad.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, "ReactiveTests.Tests.RemotingTest");
+            return test;
+        }
+    }
+
+    public class RemotingTest : MarshalByRefObject
+    {
+        public override object InitializeLifetimeService()
+        {
+            return null;
+        }
+
+        public IObservable<int> Empty()
+        {
+            return Observable.Empty<int>().Remotable();
+        }
+
+        public IObservable<int> Return(int value)
+        {
+            return Observable.Return<int>(value).Remotable();
+        }
+
+        public IObservable<int> ReturnLongLease(int value)
+        {
+            return Observable.Return<int>(value).Remotable(null);
+        }
+
+        public IObservable<int> Throw(Exception ex)
+        {
+            return Observable.Throw<int>(ex).Remotable();
+        }
+
+        public IObservable<int> Disposal()
+        {
+            return Observable.Create<int>(obs =>
+            {
+                return () => { Disposed = true; };
+            }).Remotable();
+        }
+
+        public bool Disposed { get; set; }
+    }
+}
+#endif

external/rx/Rx/NET/Source/Tests.System.Reactive/Tests/Linq/ObservableSafetyTest.cs

@@ -0,0 +1,291 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Threading;
+using Microsoft.Reactive.Testing;
+#if NUNIT
+using NUnit.Framework;
+using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
+using TestMethodAttribute = NUnit.Framework.TestAttribute;
+using TestInitializeAttribute = NUnit.Framework.SetUpAttribute;
+#else
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+#endif
+
+namespace ReactiveTests.Tests
+{
+    [TestClass]
+    public partial class ObservableSafetyTest : ReactiveTest
+    {
+        [TestMethod]
+        public void SubscribeSafe_ArgumentChecking()
+        {
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.SubscribeSafe<int>(default(IObservable<int>), Observer.Create<int>(_ => { })));
+            ReactiveAssert.Throws<ArgumentNullException>(() => ObservableExtensions.SubscribeSafe<int>(Observable.Return(42), default(IObserver<int>)));
+        }
+
+        [TestMethod]
+        public void Safety_Subscription1()
+        {
+            var ex = new Exception();
+
+            var xs = new RogueObservable(ex);
+            var res = xs.Where(x => true).Select(x => x);
+
+            var err = default(Exception);
+            var d = res.Subscribe(x => { Assert.Fail(); }, ex_ => { err = ex_; }, () => { Assert.Fail(); });
+
+            Assert.AreSame(ex, err);
+
+            d.Dispose();
+        }
+
+        [TestMethod]
+        public void Safety_Subscription2()
+        {
+            var ex = new Exception();
+
+            var scheduler = new TestScheduler();
+
+            var xs = scheduler.CreateHotObservable<int>(
+                OnNext(210, 42),
+                OnNext(220, 43),
+                OnNext(230, 44),
+                OnNext(240, 45),
+                OnCompleted<int>(250)
+            );
+
+            var ys = new RogueObservable(ex);
+
+            var res = scheduler.Start(() =>
+                xs.Merge(ys)
+            );
+
+            res.Messages.AssertEqual(
+                OnError<int>(200, ex)
+            );
+
+            xs.Subscriptions.AssertEqual(
+                Subscribe(200, 200)
+            );
+        }
+
+        class RogueObservable : IObservable<int>
+        {
+            private readonly Exception _ex;
+
+            public RogueObservable(Exception ex)
+            {
+                _ex = ex;
+            }
+
+            public IDisposable Subscribe(IObserver<int> observer)
+            {
+                throw _ex;
+            }
+        }
+
+        [TestMethod]
+        public void ObservableBase_ObserverThrows()
+        {
+            var ex = new Exception();
+
+            var failed = new ManualResetEvent(false);
+            var disposed = new ManualResetEvent(false);
+            var err = default(Exception);
+
+            var xs = Observable.Create<int>(observer =>
+            {
+                Scheduler.Default.Schedule(() =>
+                {
+                    try
+                    {
+                        observer.OnNext(42);
+                    }
+                    catch (Exception ex_)
+                    {
+                        err = ex_;
+                        failed.Set();
+                    }
+                });
+
+                return () => { disposed.Set(); };
+            });
+
+            xs.Subscribe(x =>
+            {
+                throw ex;
+            });
+
+            // Can't use WaitAll - we're on an STA thread.
+            disposed.WaitOne();
+            failed.WaitOne();
+
+            Assert.AreSame(ex, err);
+        }
+
+        [TestMethod]
+        public void ObservableBase_ObserverThrows_CustomObserver()
+        {
+            var ex = new Exception();
+
+            var failed = new ManualResetEvent(false);
+            var disposed = new ManualResetEvent(false);
+            var err = default(Exception);
+
+            var xs = Observable.Create<int>(observer =>
+            {
+                Scheduler.Default.Schedule(() =>
+                {
+                    try
+                    {
+                        observer.OnNext(42);
+                    }
+                    catch (Exception ex_)
+                    {
+                        err = ex_;
+                        failed.Set();
+                    }
+                });
+
+                return () => { disposed.Set(); };
+            });
+
+            xs.Subscribe(new MyObserver(_ => true, ex));
+
+            // Can't use WaitAll - we're on an STA thread.
+            disposed.WaitOne();
+            failed.WaitOne();
+
+            Assert.AreSame(ex, err);
+        }
+
+        [TestMethod]
+        public void Producer_ObserverThrows()
+        {
+            var ex = new Exception();
+
+            var scheduler = new TestScheduler();
+
+            var xs = scheduler.CreateHotObservable<int>(
+                OnNext(210, 1),
+                OnNext(220, 2),
+                OnNext(230, 3)
+            );
+
+            var ys = scheduler.CreateHotObservable<int>(
+                OnNext(215, 1),
+                OnNext(225, 2),
+                OnNext(235, 3)
+            );
+
+            var res = xs.CombineLatest(ys, (x, y) => x + y); // This creates a Producer object
+
+            scheduler.ScheduleAbsolute(200, () =>
+            {
+                res.Subscribe(z =>
+                {
+                    if (z == 4)
+                        throw ex;
+                });
+            });
+
+            try
+            {
+                scheduler.Start();
+                Assert.Fail();
+            }
+            catch (Exception err)
+            {
+                Assert.AreSame(ex, err);
+            }
+
+            Assert.AreEqual(225, scheduler.Clock);
+
+            xs.Subscriptions.AssertEqual(
+                Subscribe(200, 225)
+            );
+
+            ys.Subscriptions.AssertEqual(
+                Subscribe(200, 225)
+            );
+        }
+
+        [TestMethod]
+        public void Producer_ObserverThrows_CustomObserver()
+        {
+            var ex = new Exception();
+
+            var scheduler = new TestScheduler();
+
+            var xs = scheduler.CreateHotObservable<int>(
+                OnNext(210, 1),
+                OnNext(220, 2),
+                OnNext(230, 3)
+            );
+
+            var ys = scheduler.CreateHotObservable<int>(
+                OnNext(215, 1),
+                OnNext(225, 2),
+                OnNext(235, 3)
+            );
+
+            var res = xs.CombineLatest(ys, (x, y) => x + y); // This creates a Producer object
+
+            scheduler.ScheduleAbsolute(200, () =>
+            {
+                res.Subscribe(new MyObserver(x => x == 4, ex));
+            });
+
+            try
+            {
+                scheduler.Start();
+                Assert.Fail();
+            }
+            catch (Exception err)
+            {
+                Assert.AreSame(ex, err);
+            }
+
+            Assert.AreEqual(225, scheduler.Clock);
+
+            xs.Subscriptions.AssertEqual(
+                Subscribe(200, 225)
+            );
+
+            ys.Subscriptions.AssertEqual(
+                Subscribe(200, 225)
+            );
+        }
+
+        class MyObserver : ObserverBase<int>
+        {
+            private readonly Func<int, bool> _predicate;
+            private readonly Exception _exception;
+
+            public MyObserver(Func<int, bool> predicate, Exception exception)
+            {
+                _predicate = predicate;
+                _exception = exception;
+            }
+
+            protected override void OnNextCore(int value)
+            {
+                if (_predicate(value))
+                    throw _exception;
+            }
+
+            protected override void OnErrorCore(Exception error)
+            {
+            }
+
+            protected override void OnCompletedCore()
+            {
+            }
+        }
+
+    }
+}

external/rx/Rx/NET/Source/Tests.System.Reactive/Tests/Linq/ObservableSingleTest.cs.REMOVED.git-id

@@ -0,0 +1 @@
+ab3e3e87ab2deafb54cb4bfa7436d7cddffa68e8

external/rx/Rx/NET/Source/Tests.System.Reactive/Tests/Linq/ObservableStandardQueryOperatorTest.cs.REMOVED.git-id

@@ -0,0 +1 @@
+bf147e5cbc1722bd3ccb74c57a5b3c5bb87699d7

external/rx/Rx/NET/Source/Tests.System.Reactive/Tests/Linq/ObservableTimeTest.cs.REMOVED.git-id

@@ -0,0 +1 @@
+3796ed17fda790a48251d9997e1cc573fb1e0052

external/rx/Rx/NET/Source/Tests.System.Reactive/Tests/Linq/QbservableExTest.cs

@@ -0,0 +1,82 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_REFLECTION_EMIT
+#if !SILVERLIGHTM7
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reactive.Linq;
+using Microsoft.Reactive.Testing;
+#if NUNIT
+using NUnit.Framework;
+using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
+using TestMethodAttribute = NUnit.Framework.TestAttribute;
+using TestInitializeAttribute = NUnit.Framework.SetUpAttribute;
+#else
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+#endif
+
+namespace ReactiveTests.Tests
+{
+    [TestClass]
+    public class QbservableExTest : ReactiveTest
+    {
+        private IQbservable<int> _qbNull = null;
+        private IQbservable<int> _qbMy = new MyQbservable<int>();
+        private IQbservableProvider _qbp = new MyQbservableProvider();
+
+        [TestMethod]
+        public void ForkJoin_ArgumentNullChecks()
+        {
+            ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.ForkJoin(_qbNull, _qbMy, (a, b) => a + b));
+            ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.ForkJoin(_qbMy, _qbNull, (a, b) => a + b));
+            ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.ForkJoin(_qbMy, _qbMy, default(Expression<Func<int, int, int>>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.ForkJoin(default(IQbservableProvider), _qbMy));
+            ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.ForkJoin(_qbp, default(IQbservable<int>[])));
+            ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.ForkJoin(default(IQbservableProvider), new MyQueryable<IObservable<int>>()));
+            ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.ForkJoin(_qbp, default(IQueryable<IObservable<int>>)));
+        }
+
+        [TestMethod]
+        public void ForkJoin()
+        {
+            _qbMy.ForkJoin(_qbMy, (a, b) => a + b);
+            _qbp.ForkJoin(_qbMy, _qbMy);
+            _qbp.ForkJoin(new MyQueryable<IObservable<int>>());
+        }
+
+        [TestMethod]
+        public void Create_ArgumentNullChecks()
+        {
+            ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.Create<int>(default(IQbservableProvider), _ => new IObservable<object>[0]));
+            ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.Create<int>(_qbp, default(Expression<Func<IObserver<int>, IEnumerable<IObservable<object>>>>)));
+            ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.Create(default(IQbservableProvider), () => new IObservable<object>[0]));
+            ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.Create(_qbp, null));
+        }
+
+        [TestMethod]
+        public void Create()
+        {
+            _qbp.Create<int>(obs => new IObservable<object>[0]);
+            _qbp.Create(() => new IObservable<object>[0]);
+        }
+
+        [TestMethod]
+        public void Let_ArgumentNullChecks()
+        {
+            ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.Let(_qbNull, xs => xs));
+            ReactiveAssert.Throws<ArgumentNullException>(() => QbservableEx.Let(_qbMy, default(Expression<Func<IObservable<int>, IObservable<int>>>)));
+        }
+
+        [TestMethod]
+        public void Let()
+        {
+            _qbMy.Let(xs => xs);
+        }
+    }
+}
+
+#endif
+#endif