private IObservable<ManagementBaseObject> Factory(ManagementClass mc)
{
var src = new ReplaySubject<ManagementBaseObject>();
var ob = new ManagementOperationObserver();
Observable.FromEventPattern<ObjectReadyEventHandler, ObjectReadyEventArgs>(
h => h.Invoke,
h => ob.ObjectReady += h,
h => ob.ObjectReady -= h
).Subscribe(obj => src.OnNext(obj.EventArgs.NewObject));
Observable.FromEventPattern<CompletedEventHandler, CompletedEventArgs>(
h => h.Invoke,
h => ob.Completed += h,
h => ob.Completed -= h
).Subscribe(_ => src.OnCompleted());
mc.GetInstances(ob);
return src.AsObservable();
}
public void TestStringStream_Observed_Replay_Mapped_Copy()
{
ReplaySubject <string> subject = new ReplaySubject <string>();
Stream <string> stream = new Stream <string>(subject.AsObservable());
IStream <int[]> mappedStream = stream.Map(s => new int[int.Parse(s)]);
IStream <int[]> copyStream = mappedStream.Copy();
subject.OnNext("1");
Assert.IsTrue(new int[1].SequenceEqual(copyStream.Read()));
subject.OnNext("2");
Assert.IsTrue(new int[2].SequenceEqual(copyStream.Read()));
Assert.AreEqual(2, copyStream.Count());
}
public TimeEntriesLogViewSource()
{
if (!NSThread.Current.IsMainThread)
{
throw new InvalidOperationException($"{nameof(TimeEntriesLogViewSource)} must be created on the main thread");
}
if (!UIDevice.CurrentDevice.CheckSystemVersion(11, 0))
{
deleteTableViewRowAction = createLegacySwipeDeleteAction();
}
ContinueTap = continueTapSubject.AsObservable();
SwipeToContinue = swipeToContinueSubject.AsObservable();
SwipeToDelete = swipeToDeleteSubject.AsObservable();
ToggleGroupExpansion = toggleGroupExpansionSubject.AsObservable();
FirstCell = firstCellSubject.AsObservable();
IsDragging = isDraggingSubject.AsObservable();
}
public void TitleChangedEventNotRaisedTest()
{
var winChanged = new Mock <IWindowChangedNotifier>();
var titleChanged = new Mock <ITitleChangedNotifier>();
var syncContext = new SyncContextMock();
var subject = new ReplaySubject <WinChangedArgs>();
winChanged.Setup(w => w.WinChangedObservable).Returns(Observable.Return(new WinChangedArgs("title2", IntPtr.Zero)));
titleChanged.Setup(t => t.TitleChangedObservable).Returns(subject.AsObservable());
var notifier = new AppChangedNotifier(winChanged.Object, titleChanged.Object, syncContext);
var eventCalled = false;
notifier.AppChangedObservable.Subscribe(w =>
{
eventCalled = true;
});
subject.OnNext(new WinChangedArgs("title", (IntPtr)10));
Assert.IsFalse(eventCalled, "app changed event should not be raised if event window handle is not same as active handle");
}
public void TestEndOfStream_Observed_Delayed()
{
ReplaySubject <string> subject = new ReplaySubject <string>();
Stream <string> stream = new Stream <string>(subject.AsObservable());
Assert.IsFalse(stream.EndOfStream);
Assert.AreEqual(null, stream.Read());
Assert.IsFalse(stream.EndOfStream);
subject.OnNext("1");
subject.OnNext("2");
subject.OnNext("3");
subject.OnCompleted();
Assert.AreEqual("1", stream.Read());
Assert.AreEqual("2", stream.Read());
Assert.AreEqual("3", stream.Read());
Assert.IsNull(stream.Read());
Assert.IsTrue(stream.EndOfStream);
}
public void WinChangedEventTest()
{
var winChanged = new Mock <IWindowChangedNotifier>();
var titleChanged = new Mock <ITitleChangedNotifier>();
var syncContext = new SyncContextMock();
var subject = new ReplaySubject <WinChangedArgs>();
winChanged.Setup(w => w.WinChangedObservable).Returns(subject.AsObservable());
titleChanged.Setup(t => t.TitleChangedObservable).Returns(Observable.Return(new WinChangedArgs("title2", IntPtr.Zero)));
var notifier = new AppChangedNotifier(winChanged.Object, titleChanged.Object, syncContext);
var eventCalled = false;
notifier.AppChangedObservable.Subscribe(w =>
{
Assert.AreEqual("title", w.LogInfo.WindowTitle);
eventCalled = true;
});
subject.OnNext(new WinChangedArgs("title", (IntPtr)10));
Assert.IsTrue(eventCalled);
}
public PaginationBaseService(string baseUrl,
Func <string, CancellationToken, Task <HttpResponseMessage> > getHttpAsync,
DefaultPaginationOptions options = null)
{
_baseUrl = baseUrl ?? string.Empty;
_getHttpAsync = getHttpAsync ?? throw new ArgumentNullException(nameof(getHttpAsync));
PaginationResult = _paginationResultSource.AsObservable();
RequestRunning = _requestRunningSource.AsObservable();
if (options != null)
{
Page = options.Page;
PageSize = options.PageSize;
SetSortProperty(options.SortProperty);
SortDescending = options.SortDescending;
SetThenSortProperty(options.ThenSortProperty);
ThenSortDescending = options.ThenSortDescending;
}
SetupQuerySubscription();
BuildUrl();
}
public PeerSyncManager(IPeerClient peerClient,
IPeerRepository peerRepository,
IPeerService peerService,
IUserOutput userOutput,
IDeltaHeightWatcher deltaHeightWatcher,
IDfsService dfsService,
double threshold = 0.5d,
int minimumPeers = 2,
IScheduler scheduler = null)
{
_peerClient = peerClient;
_peerRepository = peerRepository;
_peerService = peerService;
_userOutput = userOutput;
_deltaHeightWatcher = deltaHeightWatcher;
_dfsService = dfsService;
_scoredDeltaIndexRangeSubject =
new ReplaySubject <IEnumerable <DeltaIndex> >(1, scheduler ?? Scheduler.Default);
ScoredDeltaIndexRange = _scoredDeltaIndexRangeSubject.AsObservable();
_threshold = threshold;
_minimumPeers = minimumPeers;
}
public void TitleChangedEventRaisedTest()
{
var windowChanged = new Mock <IWindowChangedNotifier>();
var titleChanged = new Mock <ITitleChangedNotifier>();
var syncContext = new SyncContextMock();
var windowSubject = new ReplaySubject <WinChangedArgs>();
var titleSubject = new ReplaySubject <WinChangedArgs>();
windowChanged.Setup(w => w.WinChangedObservable).Returns(windowSubject.AsObservable());
titleChanged.Setup(t => t.TitleChangedObservable).Returns(titleSubject.AsObservable());
var notifier = new AppChangedNotifier(windowChanged.Object, titleChanged.Object, syncContext);
windowSubject.OnNext(new WinChangedArgs("title", (IntPtr)10));
var eventRaised = false;
notifier.AppChangedObservable.Subscribe(a => { eventRaised = true; });
titleSubject.OnNext(new WinChangedArgs("other title", (IntPtr)10));
Assert.IsTrue(eventRaised, "app changed event should be raised if event window handle is the same as active handle and window titles are different");
}
public RpcClientTests()
{
_testScheduler = new TestScheduler();
_logger = Substitute.For <ILogger>();
_peerIdentifier = PeerIdHelper.GetPeerId("Test");
_channelHandlerContext = Substitute.For <IChannelHandlerContext>();
_channelFactory = Substitute.For <ITcpClientChannelFactory>();
_clientEventLoopGroupFactory = Substitute.For <ITcpClientEventLoopGroupFactory>();
_mockSocketReplySubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1, _testScheduler);
var mockChannel = Substitute.For <IChannel>();
var mockEventStream = _mockSocketReplySubject.AsObservable();
var observableChannel = new ObservableChannel(mockEventStream, mockChannel);
_channelFactory.BuildChannelAsync(_clientEventLoopGroupFactory, Arg.Any <IPAddress>(), Arg.Any <int>(),
Arg.Any <X509Certificate2>()).Returns(observableChannel);
_rpcClientConfig = Substitute.For <IRpcClientConfig>();
_rpcClientConfig.HostAddress = IPAddress.Any;
_rpcClientConfig.NodeId = "0";
_rpcClientConfig.PfxFileName = "pfx";
_rpcClientConfig.Port = 9000;
}
public OpenRGBSource(
OpenRGBSourceOptions options,
IOpenRGBClient client,
IObservable <long> pollingInterval
) : base(options)
{
Options = options;
Value = Subject.AsObservable();
Client = client;
pollingInterval.Subscribe((_) =>
{
var devices = Client.RequestCatching(() => Client.GetAllControllerData());
if (LastDevices != null && devices.SequenceEqual(LastDevices, new DeviceEqualityComparer()))
{
return;
}
Logger.Info($"OpenRGB device color changed");
LastDevices = devices;
var deviceStates = new Dictionary <string, DeviceState>();
devices.ToList().ForEach(it =>
{
deviceStates.Add(it.Name, new DeviceState()
{
Colors = it.Colors.Select(color => color.ToSystemColor())
});
});
Subject.OnNext(deviceStates);
});
}
public void TestStringStream_Observed_Replay_Mapped()
{
ReplaySubject <string> subject = new ReplaySubject <string>();
Stream <string> stream = new Stream <string>(subject.AsObservable());
IStream <int[]> mappedStream = stream.Map(s => new int[int.Parse(s)]);
subject.OnNext("1");
Debug.WriteLine("> Reading from mapped stream");
Assert.IsTrue(new int[1].SequenceEqual(mappedStream.Read()));
Debug.WriteLine("> Reading from base stream");
Assert.AreEqual(null, stream.Read());
subject.OnNext("2");
Debug.WriteLine("> Reading from base stream");
Assert.AreEqual("2", stream.Read());
Debug.WriteLine("> Reading from mapped stream");
Assert.AreEqual(null, mappedStream.Read());
Assert.AreEqual(2, stream.Count());
Assert.AreEqual(2, mappedStream.Count());
}
public ActivityState()
{
AllPoints = new XPoint[0];
_subject = new ReplaySubject <PropertyChange> ();
Changed = _subject.AsObservable();
}
public IObservable <T> GetResult()
{
return(_result.AsObservable()
.Take(1));
}
protected Dialog()
{
_result = new ReplaySubject <TResult>();
Result = _result.AsObservable();
}
public IObservable <int> BufferingProgress()
{
return(_playerBufferingSubject.AsObservable());
}
public IObservable <bool> StreamBuffering()
{
return(_bufferingSubject.AsObservable()
.DistinctUntilChanged()); // State gets updated "per packet". Only change is required.
}
private void ListHoldingHistory(object sender, RoutedEventArgs e)
{
var disp = AvxFsoHolding.AsObservable().Subscribe(x => Dispatcher.Invoke(() => AppendText(HoldingHistory, x)));
disp.Dispose();
}
public IObservable <IEnumerable <ConnectionType> > InternetConnectivity()
{
return(_internetConnection.AsObservable());
}
public IObservable <TDialogModel> GetResult()
{
return(_result.AsObservable().Take(1));
}
public IObservable <T> GetResult() => _result.AsObservable().Take(1);
public IObservable <Message> GetMessages()
{
return(_messageStream.AsObservable());
}
public IObservable <PlayerState> StateChanged()
{
return(_playerStateSubject.AsObservable());
}
public static IObservable <Either <IObservable <TSource>, TSource> > Introspect <TSource>(
this IObservable <TSource> source,
IScheduler scheduler)
{
Contract.Requires(source != null);
Contract.Requires(scheduler != null);
Contract.Ensures(Contract.Result <IObservable <Either <IObservable <TSource>, TSource> > >() != null);
return(EitherObservable.Create <IObservable <TSource>, TSource>(
observer =>
{
var subject = new Subject <Tuple <TSource, ISubject <TSource> > >();
var observations = Subject.Synchronize(subject, scheduler);
int pendingOnNext = 0;
bool sourceCompleted = false;
object gate = new object();
var observationsSubscription = observations.SubscribeSafe(
next =>
{
var value = next.Item1;
var introspection = next.Item2;
try
{
lock (gate)
{
observer.OnNextRight(value);
}
}
catch (Exception ex)
{
introspection.OnError(ex);
return;
}
introspection.OnCompleted();
lock (gate)
{
if (--pendingOnNext == 0 && sourceCompleted)
{
observer.OnCompleted();
}
}
},
ex =>
{
lock (gate)
{
observer.OnError(ex);
}
},
() =>
{
lock (gate)
{
observer.OnCompleted();
}
});
var sourceSubscription = source.SubscribeSafe(
value =>
{
var introspection = new ReplaySubject <TSource>(1);
lock (gate)
{
observer.OnNextLeft(introspection.AsObservable());
pendingOnNext++;
}
introspection.OnNext(value);
observations.OnNext(Tuple.Create(value, (ISubject <TSource>)introspection));
},
observations.OnError,
() =>
{
bool completeNow = false;
lock (gate)
{
sourceCompleted = true;
completeNow = pendingOnNext == 0;
}
if (completeNow)
{
observations.OnCompleted();
}
});
return new CompositeDisposable(sourceSubscription, observationsSubscription, subject);
}));
}
public IObservable <byte[]> GetResponseStream()
{
return(_dataStream.AsObservable());
}
public IObservable <bool> IsInternetConnectivityAvailable()
{
return(_isInternetConnectivityAvailable.AsObservable());
}
public void Init()
{
_cancellationToken = new CancellationToken();
_manualResetEventSlim = new ManualResetEventSlim(false);
_testScheduler = new TestScheduler();
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_peerSettings = Substitute.For <IPeerSettings>();
_peerSettings.PeerId.Returns(PeerIdHelper.GetPeerId());
_deltaDfsReader = Substitute.For <IDeltaDfsReader>();
_deltaDfsReader.TryReadDeltaFromDfs(Arg.Any <Cid>(), out Arg.Any <Delta>()).Returns(x => true);
_deltaCache = Substitute.For <IDeltaCache>();
_deltaCache.GenesisHash.Returns("bafk2bzacecji5gcdd6lxsoazgnbg46c3vttjwwkptiw27enachziizhhkir2w".ToCid());
_ledger = Substitute.For <ILedger>();
_peerService = Substitute.For <IPeerService>();
_deltaHashProvider = new DeltaHashProvider(_deltaCache, Substitute.For <IDeltaIndexService>(), Substitute.For <ILogger>());
_deltaIndexService = new DeltaIndexService(new InMemoryRepository <DeltaIndexDao, string>());
_deltaIndexService.Add(new DeltaIndexDao {
Cid = _hashProvider.ComputeUtf8MultiHash("0").ToCid(), Height = 0
});
_peerClient = Substitute.For <IPeerClient>();
ModifyPeerClient <LatestDeltaHashRequest>((request, senderPeerIdentifier) =>
{
var deltaHeightResponse = new LatestDeltaHashResponse
{
DeltaIndex = new DeltaIndex
{
Cid = _hashProvider.ComputeUtf8MultiHash(_syncTestHeight.ToString()).ToCid().ToArray()
.ToByteString(),
Height = (uint)_syncTestHeight
}
};
_deltaHeightReplaySubject.OnNext(new ObserverDto(Substitute.For <IChannelHandlerContext>(),
deltaHeightResponse.ToProtocolMessage(senderPeerIdentifier, CorrelationId.GenerateCorrelationId())));
});
ModifyPeerClient <DeltaHistoryRequest>((request, senderPeerIdentifier) =>
{
var data = GenerateSampleData((int)request.Height, (int)request.Range, (int)_syncTestHeight);
_deltaIndexService.Add(data.DeltaIndex.Select(x => DeltaIndexDao.ToDao <DeltaIndex>(x, _mapperProvider)));
_deltaHistoryReplaySubject.OnNext(new ObserverDto(Substitute.For <IChannelHandlerContext>(),
data
.ToProtocolMessage(senderPeerIdentifier, CorrelationId.GenerateCorrelationId())));
});
_peerRepository = new PeerRepository(new InMemoryRepository <Peer, string>());
Enumerable.Repeat(new Peer {
PeerId = PeerIdHelper.GetPeerId()
}, 5).ToList().ForEach(_peerRepository.Add);
_deltaHeightReplaySubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1);
_deltaHistoryReplaySubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1);
var mergeMessageStreams = _deltaHeightReplaySubject.AsObservable()
.Merge(_deltaHistoryReplaySubject.AsObservable());
_peerService.MessageStream.Returns(mergeMessageStreams);
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_deltaHashProvider.TryUpdateLatestHash(Arg.Any <Cid>(), Arg.Any <Cid>()).Returns(true);
_mapperProvider = new TestMapperProvider();
_userOutput = Substitute.For <IUserOutput>();
_deltaHeightWatcher = new DeltaHeightWatcher(_peerClient, _peerRepository, _peerService, minimumPeers: 0);
var dfsService = Substitute.For <IDfsService>();
_peerSyncManager = new PeerSyncManager(_peerClient, _peerRepository,
_peerService, _userOutput, _deltaHeightWatcher, Substitute.For <IDfsService>(), 0.7, 0);
}
