public void AsyncReactiveSubjectBase_SubscribeAsync() { var s = new MyAsyncReactiveSubject <int>(); var iv2 = default(IAsyncReactiveObserver <int>); var uri2 = default(Uri); var state2 = default(object); s.SubscribeImpl = async(o, u, x, ct) => { iv2 = o; uri2 = u; state2 = x; await Task.Yield(); return(null); }; var iv = new MyObserver <int>(); var uri = new Uri("foo://bar"); var state = "qux"; s.SubscribeAsync(iv, uri, state, CancellationToken.None).Wait(); Assert.AreSame(iv, iv2); Assert.AreSame(uri, uri2); Assert.AreSame(state, state2); }
public void AsyncReactiveObservableBase_Subscribe() { var s = new MyAsyncReactiveObservable <int>(); var iv2 = default(IAsyncReactiveObserver <int>); var uri2 = default(Uri); var state2 = default(object); s.SubscribeAsyncImpl = (o, u, x, token) => { iv2 = o; uri2 = u; state2 = x; return(Task.FromResult <IAsyncReactiveSubscription>(null)); }; var iv = new MyObserver <int>(); var uri = new Uri("foo://bar"); var state = "qux"; _ = s.SubscribeAsync(iv, uri, state).Result; Assert.AreSame(iv, iv2); Assert.AreSame(uri, uri2); Assert.AreSame(state, state2); }
public void ReactiveObservableBase_Subscribe() { var s = new MyReactiveObservable <int>(); var iv2 = default(IReactiveObserver <int>); var uri2 = default(Uri); var state2 = default(object); s.SubscribeImpl = (o, u, x) => { iv2 = o; uri2 = u; state2 = x; return(null); }; var iv = new MyObserver <int>(); var uri = new Uri("foo://bar"); var state = "qux"; s.Subscribe(iv, uri, state); Assert.AreSame(iv, iv2); Assert.AreSame(uri, uri2); Assert.AreSame(state, state2); }
public void AsObserver_Hides() { var obs = new MyObserver(); var res = obs.AsObserver(); Assert.IsFalse(object.ReferenceEquals(obs, res)); }
public void TestSpecialInterfaces() { var specialPerson = new SpecialPerson(); var myObserver = new MyObserver(); IDisposable subscription = specialPerson.Subscribe(myObserver); specialPerson.FallIll(); }
public void Do4() { var obs = new MyObserver(); Enumerable.Range(0, 10).Do(obs).ForEach(_ => { }); Assert.IsTrue(obs.Done); Assert.AreEqual(45, obs.Sum); }
private static void Qbserver_ReentrancyDuringInitialization_Impl(Func <IAsyncReactiveQbserver <int>, Task> action, Func <MyObserver <int>, TaskCompletionSource <object> > complete, Action <MyObserver <int> > assert) { var provider = new MyProvider(); var observer = provider.CreateQbserver <int>(Expression.Default(typeof(IAsyncReactiveQbserver <int>))); var opAsync = action(observer); provider.Acquire.WaitOne(); AssertEx.ThrowsException <AggregateException>( () => { observer.OnNextAsync(43, CancellationToken.None).Wait(); }, ex => { var ioe = ex.InnerException as InvalidOperationException; Assert.IsNotNull(ioe); Assert.IsTrue(ioe.Message.Contains("Concurrent calls")); }); AssertEx.ThrowsException <AggregateException>( () => { observer.OnErrorAsync(new Exception(), CancellationToken.None).Wait(); }, ex => { var ioe = ex.InnerException as InvalidOperationException; Assert.IsNotNull(ioe); Assert.IsTrue(ioe.Message.Contains("Concurrent calls")); }); AssertEx.ThrowsException <AggregateException>( () => { observer.OnCompletedAsync(CancellationToken.None).Wait(); }, ex => { var ioe = ex.InnerException as InvalidOperationException; Assert.IsNotNull(ioe); Assert.IsTrue(ioe.Message.Contains("Concurrent calls")); }); var iv = new MyObserver <int>(); var tcs = provider.GetObserverAsyncCoreTask; tcs.SetResult(iv); complete(iv).SetResult(null); opAsync.Wait(); assert(iv); }
public void IObservable_Subscribe() { // Arrange var observable = new MyObservable(); var observer = new MyObserver(); // Act observable.Subscribe(observer); // Assert }
public void ReactiveObservableBase_Subscribe_ArgumentChecking() { var s = new MyReactiveObservable <int>(); var iv = new MyObserver <int>(); var uri = new Uri("foo://bar"); var state = "qux"; Assert.ThrowsException <ArgumentNullException>(() => s.Subscribe(null, uri, state)); Assert.ThrowsException <ArgumentNullException>(() => s.Subscribe(iv, null, state)); }
public void AsyncReactiveSubjectBase_SubscribeAsync_ArgumentChecking() { var s = new MyAsyncReactiveSubject <int>(); var iv = new MyObserver <int>(); var uri = new Uri("foo://bar"); var state = "qux"; Assert.ThrowsException <ArgumentNullException>(() => s.SubscribeAsync(null, uri, state, CancellationToken.None)); Assert.ThrowsException <ArgumentNullException>(() => s.SubscribeAsync(iv, null, state, CancellationToken.None)); }
public void StatefulObserver_Basics() { { var mo = new MyObserver(); mo.Start(); Assert.IsTrue(mo.Started); //Assert.IsFalse(mo.StateChanged); // TODO: Hmm, can we do this? mo.OnNext(42); mo.OnNext(43); mo.OnCompleted(); Assert.IsTrue(new[] { 42, 43 }.SequenceEqual(mo.Values)); Assert.IsTrue(mo.Done); mo.Dispose(); Assert.IsTrue(mo.Disposed); mo.Dispose(); Assert.IsTrue(mo.Disposed); } { var mo = new MyObserver(); mo.Start(); Assert.IsTrue(mo.Started); //Assert.IsFalse(mo.StateChanged); // TODO: Hmm, can we do this? var ex = new Exception(); mo.OnNext(42); mo.OnNext(43); mo.OnError(ex); Assert.IsTrue(new[] { 42, 43 }.SequenceEqual(mo.Values)); Assert.AreSame(ex, mo.Error); mo.Dispose(); Assert.IsTrue(mo.Disposed); mo.Dispose(); Assert.IsTrue(mo.Disposed); } }
public void ToNotifier_Forwards() { var obsn = new MyObserver(); obsn.ToNotifier()(Notification.CreateOnNext <int>(42)); Assert.Equal(obsn.HasOnNext, 42); var ex = new Exception(); var obse = new MyObserver(); obse.ToNotifier()(Notification.CreateOnError <int>(ex)); Assert.Same(ex, obse.HasOnError); var obsc = new MyObserver(); obsc.ToNotifier()(Notification.CreateOnCompleted <int>()); Assert.True(obsc.HasOnCompleted); }
public void ToNotifier_Forwards() { var obsn = new MyObserver(); obsn.ToNotifier()(new Notification <int> .OnNext(42)); Assert.AreEqual(obsn.HasOnNext, 42); var ex = new Exception(); var obse = new MyObserver(); obse.ToNotifier()(new Notification <int> .OnError(ex)); Assert.AreSame(ex, obse.HasOnError); var obsc = new MyObserver(); obsc.ToNotifier()(new Notification <int> .OnCompleted()); Assert.IsTrue(obsc.HasOnCompleted); }
public void AsObserver_Forwards() { var obsn = new MyObserver(); obsn.AsObserver().OnNext(42); Assert.AreEqual(obsn.HasOnNext, 42); var ex = new Exception(); var obse = new MyObserver(); obse.AsObserver().OnError(ex); Assert.AreSame(ex, obse.HasOnError); var obsc = new MyObserver(); obsc.AsObserver().OnCompleted(); Assert.IsTrue(obsc.HasOnCompleted); }
public void test_observer_notify() { MySubject subject = new MySubject(); MyObserver[] observers = new MyObserver[] { new MyObserver(), new MyObserver() }; foreach (MyObserver o in observers) { subject.attach(o); } subject.notify(); foreach (MyObserver o in observers) { Assert.IsTrue(o.hasBeenNotified); } }
public static void Test4() { var id = Thread.CurrentThread.ManagedThreadId.ToString(); Console.WriteLine($"Thread id = {id}"); IObservable <int> input = Observable.Range(1, 15); input.Where(i => i % 2 == 0).Subscribe(Console.Write); var ob = new MyObserver <int>(); var subscripttion = input.Subscribe(ob); var observable = new MyRangeObservable(5, 8); var subscription2 = observable.Subscribe(ob); subscripttion.Dispose(); subscription2.Dispose(); }
public void Qbserver_RegularFlow() { var provider = new MyProvider(); var observer = provider.CreateQbserver <int>(Expression.Default(typeof(IAsyncReactiveQbserver <int>))); var iv = new MyObserver <int>(); provider.GetObserverAsyncCoreTask.SetResult(iv); iv.OnNextTask.SetResult(null); observer.OnNextAsync(42, CancellationToken.None).Wait(); observer.OnNextAsync(43, CancellationToken.None).Wait(); observer.OnNextAsync(44, CancellationToken.None).Wait(); iv.OnCompletedTask.SetResult(null); observer.OnCompletedAsync(CancellationToken.None).Wait(); Assert.IsTrue(iv.OnNextLog.SequenceEqual(new[] { 42, 43, 44 })); Assert.IsTrue(iv.OnCompletedLog); }
public void Should_allow_rx_subscribers() { var observer = new MyObserver <A>(); using (var bus = ServiceBusFactory.New(x => { x.ReceiveFrom("loopback://localhost/queue"); x.Subscribe(s => { s.Observe(observer); s.Observe(Observer.Create <A>(m => Console.WriteLine(m.Name))); }); })) { bus.Publish(new A { Name = "Joe" }); observer.Value.Wait(8.Seconds()).ShouldBeTrue(); } }
public void StatefulObserver_Versioning_NotSupportedByDefault() { var state = new MockOperatorStateContainer(); var writerFactory = state.CreateWriter(); var readerFactory = state.CreateReader(); var mo = new MyObserver() { State = 42 }; mo.Start(); var writer = writerFactory.Create(mo); Assert.ThrowsException <NotSupportedException>(() => mo.SaveState(writer, new Version(2, 0, 0, 0))); var mor = new MyObserver(); var reader = readerFactory.Create(mor); Assert.ThrowsException <NotSupportedException>(() => mor.LoadState(reader, new Version(2, 0, 0, 0))); }
static void Main(string[] args) { var query = from n in Enumerable.Range(1, 5) select n; #region Without Rx //foreach (var item in query) //{ // Console.WriteLine(item); //} //IAmDone(); // inform external function about completion of processing #endregion #region With Rx // Implementation using Observable //Console.WriteLine("UI Thread Id : " + Thread.CurrentThread.ManagedThreadId); //var observableQuery2 = query.ToObservable(); //observableQuery2.Subscribe(DisplayNumber, IAmDone); // first function will run for each result in the observable query, second function will run at the end #endregion #region With Rx and Threading //Console.WriteLine("Threading Example"); //Console.WriteLine("UI Thread Id : " + Thread.CurrentThread.ManagedThreadId); //var observableQuery3 = query.ToObservable(NewThreadScheduler.Default); // Produces value on a diff thread than UI thread //observableQuery3.Subscribe(DisplayNumber, IAmDone); #endregion #region With Rx and Observer Pattern Console.WriteLine("With Observer Pattern"); Console.WriteLine("UI Thread Id : " + Thread.CurrentThread.ManagedThreadId); var observableQuery4 = query.ToObservable(NewThreadScheduler.Default); var observer = Observer.Create <int>(DisplayNumber); // observer creation observableQuery4.Subscribe(observer); // observer subscribing to observarble query aka subject #endregion #region With RX - Completion function Console.WriteLine("With RX - Completion function"); var newQuery = from n in Enumerable.Range(1, 25) select n.ToString(); var newObservableQuery = newQuery.ToObservable(); newObservableQuery.Subscribe(n => { Console.WriteLine(string.Format("{0}", SlowString(n))); }, IAmDone); #endregion #region Custom Observer Console.WriteLine("Custom Observer"); var numbers = new List <int> { 1, 2, 3 }.ToObservable(); var myObserver = new MyObserver(); numbers.Subscribe(myObserver); #endregion Console.ReadLine(); }
public void AddObserver(MyObserver observer) { observers.Add(observer); }
public void StatefulObserver_State() { var state = new MockOperatorStateContainer(); var writerFactory = state.CreateWriter(); var readerFactory = state.CreateReader(); var mo = new MyObserver() { State = 42 }; mo.Start(); Assert.IsTrue(mo.Started); Assert.IsTrue(mo.StateChanged); Assert.ThrowsException <ArgumentNullException>(() => mo.SaveState(null, mo.Version)); var writer = writerFactory.Create(mo); mo.SaveState(writer, mo.Version); Assert.IsTrue(mo.StateChanged); mo.OnStateSaved(); Assert.IsFalse(mo.StateChanged); var mor = new MyObserver(); var reader = readerFactory.Create(mor); Assert.ThrowsException <ArgumentNullException>(() => mor.LoadState(null, mor.Version)); mor.LoadState(reader, mor.Version); mor.Start(); Assert.IsTrue(mor.Started); Assert.AreEqual(42, mor.State); mo.State = 43; Assert.IsTrue(mo.StateChanged); writer = writerFactory.Create(mo); mo.SaveState(writer, mo.Version); mo.OnStateSaved(); Assert.IsFalse(mo.StateChanged); var moq = new MyObserver(); reader = readerFactory.Create(moq); moq.LoadState(reader, moq.Version); moq.Start(); Assert.IsTrue(moq.Started); Assert.AreEqual(43, moq.State); mo.Dispose(); Assert.IsTrue(mo.Disposed); writer = writerFactory.Create(mo); mo.SaveState(writer, mo.Version); mo.OnStateSaved(); var mop = new MyObserver(); reader = readerFactory.Create(mop); mop.LoadState(reader, mop.Version); mop.Start(); Assert.IsTrue(mop.Disposed); Assert.IsFalse(mop.Started); }
public void RemoveObserver(MyObserver observer) { observers.Remove(observer); }
public static void SubscribeService(MyObserver <T> observer) { m_Observers.Add(observer); observer.Update(m_Service); }