public static void SubscribeASync(CimSession cimSession, string cimNamespace) { try { string query = QueryInstanceCore(); //Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Press <Enter> to abort the subscription"); //Console.ResetColor(); IObservable<CimSubscriptionResult> queryInstances = cimSession.SubscribeAsync(cimNamespace, "WQL", query, GetOperationOptions()); TestObserver<CimSubscriptionResult> observer = new TestObserver<CimSubscriptionResult>(); IDisposable disposeAble = queryInstances.Subscribe(observer); Console.ReadLine(); disposeAble.Dispose(); } catch (CimException ex) { PrintCimException(ex); } catch( Exception ex) { Console.WriteLine(ex.Message); } }
static void Main(string[] args) { while (true) { try { GrainClient.Initialize(); break; } catch (Exception) { Task.Delay(500).Wait(); } } Console.WriteLine("Waiting"); Task.Delay(5000).Wait(); Console.WriteLine("Starting"); var streamProvider = GrainClient.GetStreamProvider("DSProvider"); var stream = streamProvider.GetStream<Price>(new Guid("00000000-0000-0000-0000-000000000000"), "Global"); var testObserver = new TestObserver(); stream.SubscribeAsync(testObserver).Wait(); Console.ReadLine(); }
public void CanUseTestObserver() { const string MailBoxName = "box"; const string ErrorText = "error"; using (var mailBox = new ProcessMailBox(MailBoxName, TimeSpan.FromMilliseconds(-1))) { using (var observer = new TestObserver(MailBoxName)) { var list = new List<object>(); var taskObserve = Task.Factory.StartNew( () => { observer.OnNext(PerTestResultGenerator.CreatePerfResult()); observer.OnError(new Exception(ErrorText)); observer.OnCompleted(); }); var taskMailBox = Task.Factory.StartNew( () => { list.Add(mailBox.Content); list.Add(mailBox.Content); list.Add(mailBox.Content); }); Task.WaitAll(new[] { taskObserve, taskMailBox }, TimeSpan.FromSeconds(20)).Should().BeTrue(); list.Count.Should().Be(3); list[0].Should().Be(PerTestResultGenerator.CreatePerfResult()); list[1].Should().Be(new ExperimentError(new Exception(ErrorText))); list[2].Should().Be(new ExperimentCompleted()); } } }
public void Observer_Dispose() { for (int i = 0; i < TestHelper.RACE_LOOPS; i++) { var cs = new MaybeSubject <int>(); var to = new TestObserver <int>(); var cdl = new CountdownEvent(1); Task.Factory.StartNew(() => { while (!cs.HasObserver()) { ; } to.Dispose(); cdl.Signal(); }); cs.BlockingSubscribe(to); cdl.Wait(); Assert.False(cs.HasObserver()); } }
public void OnNext_OnCompleted_Race() { var ex = new InvalidOperationException(); for (int i = 0; i < TestHelper.RACE_LOOPS; i++) { wip = 0; error = null; var to = new TestObserver <int>(); TestHelper.Race(() => { HalfSerializer.OnNext(to, 1, ref wip, ref error); }, () => { HalfSerializer.OnCompleted(to, ref wip, ref error); }); to.AssertNoError() .AssertCompleted(); Assert.True(to.ItemCount <= 1); } }
public static void CreateInstanceASync(CimSession cimSession, string cimNamespace, string cimClassName) { try { CimInstance createInstance = CreateInstanceCore(cimSession, cimNamespace, cimClassName); if (createInstance == null) { Console.WriteLine("CreateInstance operation not performed"); return; } CimAsyncResult<CimInstance> enumeratedInstances = cimSession.CreateInstanceAsync(cimNamespace, createInstance, GetOperationOptions()); TestObserver<CimInstance> observer = new TestObserver<CimInstance>(); IDisposable disposeable = enumeratedInstances.Subscribe(observer); observer.WaitForCompletion(); } catch (CimException ex) { PrintCimException(ex); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public void Basic_Observer_Dispose() { var to = new TestObserver <int>(); var cdl = new CountdownEvent(2); var us = new MonocastSubject <int>(); Task.Factory.StartNew(() => { while (to.ItemCount != 5) { ; } to.Dispose(); cdl.Signal(); }); Task.Factory.StartNew(() => { us.Emit(1, 2, 3, 4, 5); cdl.Signal(); }); us.BlockingSubscribe(to); to.AssertValuesOnly(1, 2, 3, 4, 5); Assert.True(cdl.Wait(3000)); Assert.False(us.HasObserver()); }
public void Q4() { var observer = new TestObserver <int>(); var subject1 = new Subject <int>(); var subject2 = new Subject <int>(); // Q. subject1, subject2を組み合わせ、きた順に値を流すobservableをつくれ var observable = (UniRx.IObservable <int>)null; // FIXME observable.Subscribe(observer); subject1.OnNext(1); subject2.OnNext(10); subject1.OnNext(2); subject2.OnNext(20); subject1.OnCompleted(); subject2.OnNext(30); Assert.AreEqual(5, observer.CountNext); Assert.AreEqual(1, observer.NextList[0]); Assert.AreEqual(10, observer.NextList[1]); Assert.AreEqual(2, observer.NextList[2]); Assert.AreEqual(20, observer.NextList[3]); Assert.AreEqual(30, observer.NextList[4]); }
protected TestObserver <ConnectionState> GetObserver(ClientHolder holder) { var observer = new TestObserver <ConnectionState>(); holder.OnConnectionStateChanged.Subscribe(observer); return(observer); }
// Static void method with same signature as "Main" is always // file base name: // /// <summary> /// VTK test Main method /// </summary> public static void vtkCommandTest(string[] args) { // Create an object to send an event: // Kitware.VTK.vtkObject sender = new Kitware.VTK.vtkObject(); // Create an event observer: // TestObserver observer = new TestObserver(); // Connect them: // uint observerModifiedEventTag = sender.AddObserver( (uint)Kitware.VTK.vtkCommand.EventIds.ModifiedEvent, observer, 0.69f); // Trigger the event: // sender.Modified(); // Toggle Debug, trigger event again, then turn off Debug before objects are destroyed... // sender.SetDebug((byte)((0 == sender.GetDebug()) ? 1 : 0)); sender.Modified(); sender.DebugOff(); // Disconnect them: // sender.RemoveObserver(observerModifiedEventTag); }
public void Sut_AllMethods_WhenErrorOccurs_ShouldCallOnNext( Func <ReportingActor, INamed, object> executeAction, #pragma warning disable xUnit1026 // Theory methods should use all of their parameters Func <INamed, Expression <Func <IActor, object> > > dummy, #pragma warning restore xUnit1026 // Theory methods should use all of their parameters CommandType commandType) { //arrange var fixture = CreateFixture(); var observer = new TestObserver <ActionNotification>(); fixture.Inject((IObserver <ActionNotification>)observer); var date = fixture.Freeze <DateTimeOffset>(); var measureDuration = fixture.Freeze <Mock <IMeasureDuration> >(); var sut = fixture.Create <ReportingActor>(); var action = fixture.Create <MockToString>(); var exception = fixture.Create <Exception>(); var expectedDuration = fixture.Create <TimeSpan>(); measureDuration.Setup(m => m.Measure(It.IsAny <Func <object> >())).Returns((expectedDuration, null, exception)); //act try { executeAction(sut, action); } catch { } //assert var expected = new[] { new ActionNotification(action, 1, new BeforeActionNotificationContent(date, commandType)), new ActionNotification(action, 1, new ExecutionErrorNotificationContent(exception, expectedDuration)) }; observer.Values.Should().BeEquivalentTo(expected, o => o.RespectingRuntimeTypes().ComparingByMembers <ActionNotification>()); }
public void Sut_AllMethods_WhenErrorOccurs_ShouldCallOnNext( Func <ReportingActor, INamed, object> executeAction, Func <INamed, Expression <Func <IActor, object> > > dummy) { //arrange var fixture = CreateFixture(); var observer = new TestObserver <ActionNotification>(); fixture.Inject((IObserver <ActionNotification>)observer); var measureDuration = fixture.Freeze <Mock <IMeasureDuration> >(); var sut = fixture.Create <ReportingActor>(); var action = fixture.Create <MockToString>(); var exception = fixture.Create <Exception>(); measureDuration.Setup(m => m.Measure(It.IsAny <Func <object> >())).Throws(exception); //act try { executeAction(sut, action); } catch { } //assert var expected = new[] { new ActionNotification(action, 1, new BeforeActionNotificationContent()), new ActionNotification(action, 1, new ExecutionErrorNotificationContent(exception)) }; observer.Values.ShouldAllBeEquivalentTo(expected, o => o.RespectingRuntimeTypes()); }
public void OnNext_OnError_Race() { for (int i = 0; i < TestHelper.RACE_LOOPS; i++) { var to = new TestObserver <int>(); var s = ReactiveExtensions.ToSerialized(to); var ex = new InvalidOperationException(); Action emit = () => { for (int j = 0; j < 500; j++) { s.OnNext(j); } }; Action complete = () => { for (int j = 0; j < 250; j++) { s.OnNext(j); } s.OnError(ex); }; TestHelper.Race(emit, complete); Assert.True(to.ItemCount >= 250); to.AssertError(typeof(InvalidOperationException)) .AssertNotCompleted(); } }
public void DiagnosticSourceStartStop() { using (DiagnosticListener listener = new DiagnosticListener("Testing")) { DiagnosticSource source = listener; var observer = new TestObserver(); using (listener.Subscribe(observer)) { var arguments = new { args = "arguments" }; var activity = new Activity("activity"); source.StartActivity(activity, arguments); Assert.Equal(activity.OperationName + ".Start", observer.EventName); Assert.Equal(arguments, observer.EventObject); observer.Reset(); source.StopActivity(activity, arguments); Assert.Equal(activity.OperationName + ".Stop", observer.EventName); Assert.Equal(arguments, observer.EventObject); } } }
public void Observe_should_reflect_updates_correctly() { var observer = new TestObserver <Dictionary <string, int> >(); var expectedSettings = new List <Dictionary <string, int> >(); using (var temporaryFile = new TemporaryFile()) { source = CreateJsonFileSource(temporaryFile.FileName); using (provider.Observe <Dictionary <string, int> >(source).Subscribe(observer)) { Action assertion = () => observer.Values.Should().BeEquivalentTo(expectedSettings, options => options.WithStrictOrdering()); expectedSettings.Add(new Dictionary <string, int>()); assertion.ShouldPassIn(500.Milliseconds()); File.WriteAllText(temporaryFile.FileName, "{ 'a': 1 }"); expectedSettings.Add(new Dictionary <string, int> { ["a"] = 1 }); assertion.ShouldPassIn(500.Milliseconds()); File.WriteAllText(temporaryFile.FileName, "error"); assertion.ShouldNotFailIn(500.Milliseconds()); File.WriteAllText(temporaryFile.FileName, "{ 'a': 2 }"); expectedSettings.Add(new Dictionary <string, int> { ["a"] = 2 }); assertion.ShouldPassIn(500.Milliseconds()); } } }
public void SendErrorsToCallback_should_work_correctly([Values] bool hasError) { var errorCallback = Substitute.For <Action <Exception> >(); var subject = new Subject <(object, Exception)>(); var testObserver = new TestObserver <object>(); using (subject.SendErrorsToCallback(errorCallback).Subscribe(testObserver)) { var settings = new object(); var error = hasError ? new Exception() : null; subject.OnNext((settings, error)); if (hasError) { errorCallback.Received(1).Invoke(error); testObserver.Values.Should().BeEmpty(); } else { errorCallback.DidNotReceiveWithAnyArgs().Invoke(null); testObserver.Values.Should().Equal(settings); } } }
public void Execute_WithThenActionWithError_ShouldCallOnNext( [Frozen(Matching.ImplementedInterfaces)] TestObserver <ActionNotification> observer, [Frozen] DateTimeOffset date, [Frozen] IMeasureDuration measureDuration, ReportingActor sut, ThenAction <object, string> thenAction, Exception error, TimeSpan expectedDuration ) { //arrange Mock.Get(measureDuration).Setup(m => m.Measure(It.IsAny <Func <string> >())) .Returns((expectedDuration, null, error)); //act try { sut.Execute(thenAction); } catch (Exception) { } //assert var expected = new[] { new ActionNotification(thenAction, 1, new BeforeThenNotificationContent(date, thenAction.Question)), new ActionNotification(thenAction, 1, new AfterThenNotificationContent(expectedDuration, ThenOutcome.Error, error)) }; observer.Values.Should().BeEquivalentTo(expected, o => o.RespectingRuntimeTypes().ComparingByMembers <ActionNotification>()); }
public void Q7() { var observer = new TestObserver <int[]>(); var subject1 = new Subject <int>(); var subject2 = new Subject <int>(); var subject3 = new Subject <int>(); // Q. subject1, subject2, subject3 がすべてcompleteしたら、それぞれの最後の値を流すobservableは? var observable = (UniRx.IObservable <int[]>)null; // FIXME observable.Subscribe(observer); subject1.OnNext(1); subject2.OnNext(2); subject3.OnNext(3); subject3.OnNext(4); Assert.AreEqual(0, observer.CountNext); subject1.OnCompleted(); subject2.OnCompleted(); subject3.OnCompleted(); Assert.AreEqual(1, observer.CountNext); Assert.AreEqual(new[] { 1, 2, 4 }, observer.NextList[0]); }
public void Dulicate_message_is_detected() { var streamer = EnvelopeStreamer.CreateDefault(typeof(Message)); var builder = new CqrsEngineBuilder(streamer); var cfg = new MemoryStorageConfig(); var sender = cfg.CreateSimpleSender(streamer, "in"); builder.Handle(cfg.CreateInbox("in"), envelope => Console.WriteLine("Got message")); var env = new EnvelopeBuilder("fixed ID").Build(); using (var token = new CancellationTokenSource()) using (var build = builder.Build()) using (TestObserver.When <EnvelopeDuplicateDiscarded>(discarded => token.Cancel())) { sender.SendBatch(new object[] { new Message() }, IdGeneration.HashContent); sender.SendBatch(new object[] { new Message() }, IdGeneration.HashContent); build.Start(token.Token); if (Debugger.IsAttached) { token.Token.WaitHandle.WaitOne(); } else { token.Token.WaitHandle.WaitOne(10000); } Assert.IsTrue(token.IsCancellationRequested); } }
public void ValuedSubjectTest() { var tenseSubject = new TenseSubject <int>(); var tenseObserver = new TestObserver <Tuple <int, Tense> >(); var testObserver = new TestObserver <int>(); tenseSubject.Subscribe(tenseObserver); tenseSubject.WhenDo().Subscribe(testObserver); tenseSubject.WhenWill().Subscribe(testObserver); tenseSubject.WhenDid().Subscribe(testObserver); tenseSubject.Do(4); Assert.AreEqual(4, tenseObserver.OnNextLastValue.Item1); Assert.AreEqual(Tense.Do, tenseObserver.OnNextLastValue.Item2); Assert.AreEqual(1, testObserver.OnNextCount); Assert.AreEqual(4, testObserver.OnNextLastValue); tenseSubject.Will(5); Assert.AreEqual(5, tenseObserver.OnNextLastValue.Item1); Assert.AreEqual(Tense.Will, tenseObserver.OnNextLastValue.Item2); Assert.AreEqual(2, testObserver.OnNextCount); Assert.AreEqual(5, testObserver.OnNextLastValue); tenseSubject.Did(6); Assert.AreEqual(6, tenseObserver.OnNextLastValue.Item1); Assert.AreEqual(Tense.Did, tenseObserver.OnNextLastValue.Item2); Assert.AreEqual(3, testObserver.OnNextCount); Assert.AreEqual(6, testObserver.OnNextLastValue); }
public async Task Server_ClientWebRepository_CommunicationValid() { using Server server = new Server(TEST_PORT, new DataRepository(), null); using AutoResetEvent clientConnEvent = new AutoResetEvent(false), clientDisconnEvent = new AutoResetEvent(false); server.ServerWebSocketConnection.OnError += (o, a) => Assert.Fail($"Server error! {a.Exception}"); server.ServerWebSocketConnection.OnClientConnected += (o, a) => clientConnEvent.Set(); server.ServerWebSocketConnection.OnClose += (o, a) => clientDisconnEvent.Set(); Task serverTask = Task.Run(server.RunServer); using (WebRepository client = new WebRepository()) { Assert.IsTrue(await client.OpenRepository(ClientUtil.CreateLocalConnectionString(TEST_PORT))); Assert.IsTrue(clientConnEvent.WaitOne(TEST_TIMEOUT)); Assert.AreEqual((await server.DataRepository.GetAllClients()).Count, (await client.GetAllClients()).Count); Assert.AreEqual((await server.DataRepository.GetAllProducts()).Count, (await client.GetAllProducts()).Count); Assert.AreEqual((await server.DataRepository.GetAllOrders()).Count, (await client.GetAllOrders()).Count); TestObserver testObserver = new TestObserver(); using (IDisposable _ = server.DataRepository.Subscribe((IObserver <DataChanged <IClient> >)testObserver), __ = server.DataRepository.Subscribe((IObserver <DataChanged <IProduct> >)testObserver)) { await client.RemoveClient((await client.GetAllClients()).First()); await client.RemoveProduct((await client.GetAllProducts()).First()); } Assert.AreEqual(0, testObserver.ClientErrors.Count); Assert.AreEqual(0, testObserver.ProductErrors.Count); Assert.AreEqual(1, testObserver.ClientNext.Count); Assert.AreEqual(1, testObserver.ProductNext.Count); Assert.AreEqual(DataChangedAction.Remove, testObserver.ClientNext.Dequeue().Action); Assert.AreEqual(DataChangedAction.Remove, testObserver.ProductNext.Dequeue().Action); } Assert.IsTrue(clientDisconnEvent.WaitOne(TEST_TIMEOUT)); }
public void Fail_Multi_Error_Info() { var to = new TestObserver <int>(); to.OnSubscribe(DisposableHelper.EMPTY); to.WithTag("Tag"); try { to.AwaitDone(TimeSpan.FromMilliseconds(100)); to.OnError(new NullReferenceException()); to.OnError(new InvalidOperationException()); to.AssertEmpty(); Assert.Fail(); } catch (Exception ex) { if (!ex.Message.StartsWith("Multiple errors")) { throw ex; } } }
public void SubjectTest() { var tenseSubject = new TenseSubject(); var tenseObserver = new TestObserver <Tense>(); var testObserver = new TestObserver <Unit>(); tenseSubject.Subscribe(tenseObserver); tenseSubject.WhenDo().Subscribe(testObserver); tenseSubject.WhenWill().Subscribe(testObserver); tenseSubject.WhenDid().Subscribe(testObserver); tenseSubject.Do(); Assert.AreEqual(Tense.Do, tenseObserver.OnNextLastValue); Assert.AreEqual(1, testObserver.OnNextCount); tenseSubject.Will(); Assert.AreEqual(Tense.Will, tenseObserver.OnNextLastValue); Assert.AreEqual(2, testObserver.OnNextCount); tenseSubject.Did(); Assert.AreEqual(Tense.Did, tenseObserver.OnNextLastValue); Assert.AreEqual(3, testObserver.OnNextCount); }
public void Fail_Full_Info() { var to = new TestObserver <int>(); to.OnSubscribe(DisposableHelper.EMPTY); to.WithTag("Tag"); try { to.AwaitDone(TimeSpan.FromMilliseconds(100)); to.OnCompleted(); to.AssertEmpty(); Assert.Fail(); } catch (Exception ex) { if (!ex.Message.StartsWith("Unexpected")) { throw ex; } } }
public void Enumerable_Item_Longer() { var to = new TestObserver <List <int> >(); to.OnNext(new List <int>() { 1 }); try { to.AssertValuesOnly(new List <int>() { 1, 2 }); Assert.Fail(); } catch (Exception ex) { if (!ex.Message.StartsWith("Item @ 0, more items expected")) { throw ex; } } }
public void Wrong_Enumerable() { var to = new TestObserver <List <int> >(); to.OnNext(new List <int>() { 1 }); try { to.AssertValuesOnly(new List <int>() { 2 }); Assert.Fail(); } catch (Exception ex) { if (!ex.Message.StartsWith("Item @ 0/0 differ.")) { throw ex; } } }
public void ObservableTest() { var property = new SubjectProperty <int>(); var observer = new TestObserver <int>(); property.Subscribe(observer); Assert.AreEqual(0, observer.OnNextCount); property.Value = 10; Assert.AreEqual(1, observer.OnNextCount); Assert.AreEqual(10, observer.OnNextLastValue); property.Value = 20; Assert.AreEqual(2, observer.OnNextCount); Assert.AreEqual(20, observer.OnNextLastValue); var observer2 = new TestObserver <int>(); property.Subscribe(observer2); Assert.AreEqual(0, observer2.OnNextCount); property.Value = 30; Assert.AreEqual(1, observer2.OnNextCount); Assert.AreEqual(30, observer2.OnNextLastValue); Assert.AreEqual(3, observer.OnNextCount); Assert.AreEqual(30, observer.OnNextLastValue); }
// Static void method with same signature as "Main" is always // file base name: // /// <summary> /// VTK test Main method /// </summary> public static void vtkCommandTest(string[] args) { // Create an object to send an event: // Kitware.VTK.vtkObject sender = new Kitware.VTK.vtkObject(); // Create an event observer: // TestObserver observer = new TestObserver(); // Connect them: // uint observerModifiedEventTag = sender.AddObserver( (uint) Kitware.VTK.vtkCommand.EventIds.ModifiedEvent, observer, 0.69f); // Trigger the event: // sender.Modified(); // Toggle Debug, trigger event again, then turn off Debug before objects are destroyed... // sender.SetDebug((byte)((0 == sender.GetDebug()) ? 1 : 0)); sender.Modified(); sender.DebugOff(); // Disconnect them: // sender.RemoveObserver(observerModifiedEventTag); }
public void Action_Dispose() { for (int i = 0; i < TestHelper.RACE_LOOPS; i++) { var cs = new CompletableSubject(); var to = new TestObserver <object>(); var cdl = new CountdownEvent(1); Task.Factory.StartNew(() => { while (!cs.HasObserver()) { ; } to.Dispose(); cdl.Signal(); }); cs.BlockingSubscribe(to.OnCompleted, to.OnError, to.OnSubscribe); cdl.Wait(); Assert.False(cs.HasObserver()); } }
public void Poll_GeneratesExpectedEvents() { var source = new CLRRuntimeSource(); var listener = source.Source as DiagnosticListener; var options = new MetricsEndpointOptions(); var stats = new OpenCensusStats(); var tags = new OpenCensusTags(); var observer = new TestObserver(options, stats, tags, null); listener.Subscribe(observer); source.Poll(); Assert.Equal(2, observer.Events.Count); Assert.Equal(2, observer.Args.Count); Assert.Equal(CLRRuntimeSource.HEAP_EVENT, observer.Events[0]); Assert.Equal(CLRRuntimeSource.THREADS_EVENT, observer.Events[1]); var heapMetrics = (CLRRuntimeSource.HeapMetrics)observer.Args[0]; Assert.NotEqual(0, heapMetrics.TotalMemory); Assert.NotNull(heapMetrics.CollectionCounts); Assert.NotEqual(0, heapMetrics.CollectionCounts.Count); var threadMetrics = (CLRRuntimeSource.ThreadMetrics)observer.Args[1]; Assert.NotEqual(0, threadMetrics.AvailableThreadCompletionPort); Assert.NotEqual(0, threadMetrics.AvailableThreadPoolWorkers); Assert.NotEqual(0, threadMetrics.MaxThreadCompletionPort); Assert.NotEqual(0, threadMetrics.MaxThreadPoolWorkers); }
public void Race_While() { for (int i = 0; i < TestHelper.RACE_LOOPS; i++) { var us = new MonocastSubject <int>(); var to = new TestObserver <int>(); TestHelper.Race(() => { for (int j = 0; j < 1000; j++) { us.OnNext(j); } us.OnCompleted(); }, () => { us.BlockingSubscribeWhile(v => { to.OnNext(v); return(true); }, to.OnError, to.OnCompleted); }); to.AssertValueCount(1000) .AssertNoError() .AssertCompleted(); } }
public void A4() { var testObserver1 = new TestObserver <int>(); var testObserver2 = new TestObserver <int>(); // A. var observableAndObserver = new AsyncSubject <int>(); // SUBSCRIBE ((IObserver <int>)observableAndObserver).OnNext(1); observableAndObserver.Subscribe(testObserver1); ((IObserver <int>)observableAndObserver).OnNext(2); ((IObserver <int>)observableAndObserver).OnCompleted(); observableAndObserver.Subscribe(testObserver2); // CHECK Assert.AreEqual(1, testObserver1.CountNext); Assert.AreEqual(2, testObserver1.NextList[0]); Assert.AreEqual(1, testObserver1.CountComplete); Assert.AreEqual(1, testObserver1.CountNext); Assert.AreEqual(2, testObserver1.NextList[0]); Assert.AreEqual(1, testObserver1.CountComplete); }
public void A2() { var testObserver1 = new TestObserver <int>(); var testObserver2 = new TestObserver <int>(); // A. var observableAndObserver = new BehaviorSubject <int>(1); var disposable1 = observableAndObserver.Subscribe(testObserver1); ((IObserver <int>)observableAndObserver).OnNext(2); disposable1.Dispose(); var disposable2 = observableAndObserver.Subscribe(testObserver2); ((IObserver <int>)observableAndObserver).OnNext(3); disposable2.Dispose(); // CHECK Assert.AreEqual(2, testObserver1.CountNext); Assert.AreEqual(1, testObserver1.NextList[0]); Assert.AreEqual(2, testObserver1.NextList[1]); Assert.AreEqual(2, testObserver2.CountNext); Assert.AreEqual(2, testObserver2.NextList[0]); Assert.AreEqual(3, testObserver2.NextList[1]); }
public void Race() { for (int i = 0; i < TestHelper.RACE_LOOPS; i++) { var us = new MonocastSubject <int>(); var to = new TestObserver <int>(); TestHelper.Race(() => { for (int j = 0; j < 1000; j++) { us.OnNext(j); } us.OnCompleted(); }, () => { foreach (var v in us.BlockingEnumerable()) { to.OnNext(v); } to.OnCompleted(); }); to.AssertValueCount(1000) .AssertNoError() .AssertCompleted(); } }
public void An_ObservableSink_subscriber_must_be_disposable() { var probe = new TestObserver <int>(this); var tuple = Source.Queue <int>(1, OverflowStrategy.DropHead) .ToMaterialized(Sink.AsObservable <int>(), Keep.Both) .Run(Materializer); var queue = tuple.Item1; var observable = tuple.Item2; var d1 = observable.Subscribe(probe); var t = queue.OfferAsync(1); t.Wait(TimeSpan.FromSeconds(1)).ShouldBeTrue(); t.Result.ShouldBe(QueueOfferResult.Enqueued.Instance); probe.ExpectEvent(1); t = queue.OfferAsync(2); t.Wait(TimeSpan.FromSeconds(1)).ShouldBeTrue(); t.Result.ShouldBe(QueueOfferResult.Enqueued.Instance); probe.ExpectEvent(2); d1.Dispose(); t = queue.OfferAsync(3); t.Wait(TimeSpan.FromSeconds(1)).ShouldBeTrue(); probe.ExpectCompleted(); probe.ExpectNoMsg(); }
private static void TestRead() { //var testObserver = GrainClient.GrainFactory.GetGrain<ITestObserver>(0); var testObserver = new TestObserver(); testObserver = new TestObserver(); testObserver.Subscribe(true).Wait(); }
protected override void ConfigureInputQueueEndpoint(IInMemoryReceiveEndpointConfigurator configurator) { _observer = GetObserver<A>(); configurator.Observer(_observer); configurator.Observer(Observer.Create<ConsumeContext<A>>(m => Console.WriteLine(m.Message.Name))); }
static void Main(string[] args) { // Retry till connected while (true) { try { GrainClient.Initialize(); break; } catch (Exception) { Task.Delay(500).Wait(); } } // Delay Console.WriteLine("Waiting"); Task.Delay(2000).Wait(); Console.WriteLine("Starting"); // Test: repeat till problem occurs var list = new List<TestObserver>(); while (true) { var testObserver = new TestObserver(); list.Add(testObserver); testObserver.Subscribe().Wait(); var received = false; // wait for client to receive message for (int i = 0; i < 1000; i++) { if (testObserver.ReceivedMessage) { received = true; break; } Task.Delay(5).Wait(); } //testObserver.Unsubscribe().Wait(); if (!received) { Console.WriteLine("Client did not receive the message."); break; } Task.Delay(1500).Wait(); } Console.ReadLine(); }
public void CanObserveTestRunner() { var setUpCounter = 0; var testCounter = 0; var tearDownCounter = 0; const int Start = 0; const int Step = 7; const int End = 135; const string MailBoxName = "box"; using (var mailBox = new ProcessMailBox(MailBoxName, TimeSpan.FromMilliseconds(-1))) { using (var observer = new TestObserver(MailBoxName)) { var list = new List<PerfTestResult>(); var runner = new TestRunner(i => setUpCounter++, () => testCounter++, () => tearDownCounter++, i => i / 2d, Start, Step, End); var taskObserve = Task.Factory.StartNew( () => { runner.Subscribe(observer); }); var taskMailBox = Task.Factory.StartNew( () => { for (int i = Start; i < End; i += Step) { list.Add((PerfTestResult)mailBox.Content); } }); Task.WaitAll(new[] { taskObserve, taskMailBox }, TimeSpan.FromSeconds(20)).Should().BeTrue(); var count = (int)Math.Ceiling((End - Start + 1) / (double)Step); setUpCounter.Should().Be(count); testCounter.Should().Be(count); tearDownCounter.Should().Be(count); var index = 0; for (var i = Start; i < End; i += Step) { list[index++].Descriptor.Should().Be(i / 2d); } } } }
public void Activator_And_Should_Follow_Single_Input() { var inputs = new[] { new TestSubject<bool>(false) }; var target = new StyleActivator(inputs, ActivatorMode.And); var result = new TestObserver<bool>(); target.Subscribe(result); Assert.False(result.GetValue()); inputs[0].OnNext(true); Assert.True(result.GetValue()); inputs[0].OnNext(false); Assert.False(result.GetValue()); inputs[0].OnNext(true); Assert.True(result.GetValue()); Assert.Equal(1, inputs[0].SubscriberCount); }
public void Activator_And_Should_Not_Unsubscribe_All_When_Input_Completes_On_True() { var inputs = new[] { new TestSubject<bool>(false), new TestSubject<bool>(false), new TestSubject<bool>(true), }; var target = new StyleActivator(inputs, ActivatorMode.And); var result = new TestObserver<bool>(); target.Subscribe(result); Assert.False(result.GetValue()); inputs[0].OnNext(true); inputs[0].OnCompleted(); Assert.Equal(1, inputs[0].SubscriberCount); Assert.Equal(1, inputs[1].SubscriberCount); Assert.Equal(1, inputs[2].SubscriberCount); }
public static void Start(StartParameters startParameters) { using (var testObserver = new TestObserver(startParameters.ChannelName)) { var suite = AssemblyLoader.CreateInstance<PerfTestSuite>( startParameters.SuiteAssembly, startParameters.SuiteType); var subject = AssemblyLoader.CreateInstanceFullyQualifiedName( startParameters.SubjectAssembly, startParameters.SubjectType); var start = startParameters.Start; var step = startParameters.Step; var end = startParameters.End; if (suite != null && subject != null) { var test = suite.Tests.First(x => x.TestMethodName == startParameters.TestMethod && x.TestedType == subject.GetType()); PerfTestResultFactory.Instance.Init(test.TestId); var runner = new TestRunner( delegate(int idx) { suite.SetUp(idx, subject); }, delegate { test.Test(subject); }, delegate { suite.TearDown(subject); }, delegate(int idx) { return suite.GetRunDescriptor(idx); }, string.IsNullOrEmpty(start) ? 0 : int.Parse(start), string.IsNullOrEmpty(step) ? 1 : int.Parse(step), string.IsNullOrEmpty(end) ? suite.DefaultTestCount : int.Parse(end), startParameters.IgnoreFirstRunDueToJITting, startParameters.TriggerGCBeforeEachTest); runner.Subscribe(testObserver); testObserver.OnCompleted(); } else { testObserver.OnError(new Exception()); } } }
public void Activator_And_Should_AND_Multiple_Inputs() { var inputs = new[] { new TestSubject<bool>(false), new TestSubject<bool>(false), new TestSubject<bool>(true), }; var target = StyleActivator.And(inputs); var result = new TestObserver<bool>(); target.Subscribe(result); Assert.False(result.GetValue()); inputs[0].OnNext(true); inputs[1].OnNext(true); Assert.True(result.GetValue()); inputs[0].OnNext(false); Assert.False(result.GetValue()); Assert.Equal(1, inputs[0].SubscriberCount); Assert.Equal(1, inputs[1].SubscriberCount); Assert.Equal(1, inputs[2].SubscriberCount); }
static void Main(string[] args) { while (true) { try { GrainClient.Initialize(); break; } catch (Exception) { Task.Delay(500).Wait(); } } Console.WriteLine("Waiting"); Task.Delay(2000).Wait(); Console.WriteLine("Starting"); //var testObserver = GrainClient.GrainFactory.GetGrain<ITestObserver>(0); var testObserver = new TestObserver(); testObserver.Subscribe().Wait(); Console.ReadLine(); }
public async Task Test_Observer_Succeed() { var userLogin = _actorBoundChannel.CreateRef<UserLoginRef>(); var observer = new TestObserver(); var user = await userLogin.Login( "test", "test", _actorBoundChannel.CreateObserver<IUserObserver>(observer)); await user.Say("Hello"); Assert.Equal(new[] { "Hello" }, observer.Messages); }
public static void GetInstanceASync(CimSession cimSession, string cimNamespace, string cimClassName) { // Check Arguments if (cimNamespace == null) { throw new ArgumentNullException("cimNamespace"); } if (cimClassName == null) { throw new ArgumentNullException("cimClassName"); } try { CimInstance inputInstance = GetInstanceCore(cimSession, cimNamespace, cimClassName); IObservable<CimInstance> enumeratedInstances = cimSession.GetInstanceAsync(cimNamespace, inputInstance, GetOperationOptions()); TestObserver<CimInstance> observer = new TestObserver<CimInstance>(); IDisposable disposeable = enumeratedInstances.Subscribe(observer); observer.WaitForCompletion(); } catch (CimException ex) { PrintCimException(ex); } catch( Exception ex) { Console.WriteLine(ex.Message); } }
public static void QueryInstanceASync(CimSession cimSession, string cimNamespace) { try { string query = QueryInstanceCore(); IObservable<CimInstance> queryInstances = cimSession.QueryInstancesAsync(cimNamespace, "WQL", query, GetOperationOptions()); TestObserver<CimInstance> observer = new TestObserver<CimInstance>(); IDisposable disposeable = queryInstances.Subscribe(observer); observer.WaitForCompletion(); } catch (CimException ex) { PrintCimException(ex); } catch( Exception ex) { Console.WriteLine(ex.Message); } }
public static void EnumerateAssociatedInstanceASync(CimSession cimSession, string cimNamespace, string cimClassName) { try { string resultClassName; string associationClassName; CimInstance associatedInputInstance = EnumerateAssociatedInstanceCore( cimSession, cimNamespace, cimClassName, out associationClassName, out resultClassName); if (associatedInputInstance == null) { Console.WriteLine("EnumerateAssociatedInstanceSync operation not performed"); return; } IObservable<CimInstance> enumeratedInstances = cimSession.EnumerateAssociatedInstancesAsync( cimNamespace, associatedInputInstance, associationClassName, resultClassName, null, null, GetOperationOptions()); TestObserver<CimInstance> observer = new TestObserver<CimInstance>(); IDisposable disposeable = enumeratedInstances.Subscribe(observer); observer.WaitForCompletion(); } catch (CimException ex) { PrintCimException(ex); } catch( Exception ex) { Console.WriteLine(ex.Message); } }
public static void InvokeMethodASync(CimSession cimSession, string cimNamespace, string cimClassName) { try { string methodName; CimInstance inputInstance; CimMethodParametersCollection methodParameters = InvokeMethodCore(cimSession, cimNamespace, cimClassName, out methodName, out inputInstance); if (methodParameters == null) { Console.WriteLine("Operation InvokeMethod not performed"); return; } CimAsyncMultipleResults<CimMethodResultBase> invokeParams; CimOperationOptions options = GetOperationOptions(); options.EnableMethodResultStreaming = true; if (inputInstance == null) { invokeParams = cimSession.InvokeMethodAsync(cimNamespace, cimClassName, methodName, methodParameters, options); } else { invokeParams = cimSession.InvokeMethodAsync(cimNamespace, inputInstance, methodName, methodParameters, options); } TestObserver<CimMethodResultBase> observer = new TestObserver<CimMethodResultBase>(); IDisposable disposeable = invokeParams.Subscribe(observer); observer.WaitForCompletion(); } catch (CimException ex) { PrintCimException(ex); } catch( Exception ex) { Console.WriteLine(ex.Message); } }