public void MultiplePublishers()
{
const string message1 = "Test Message #1";
const string message2 = "Test Message #2";
const string message3 = "Test Message #3";
const string message4 = "Test Message #4";
string receivedMessage = null;
var messageBus = new MessageBus();
var publisher1 = new Subject<string>();
var publisher2 = new Subject<string>();
var subscription1 = messageBus.RegisterPublisher(publisher1);
messageBus.RegisterPublisher(publisher2);
messageBus.Listen<string>().Subscribe(m => receivedMessage = m, e => Assert.Fail(), Assert.Fail);
Assert.IsNull(receivedMessage);
messageBus.Publish(message1);
Assert.AreEqual(message1, receivedMessage);
publisher1.OnNext(message2);
Assert.AreEqual(message2, receivedMessage);
publisher2.OnNext(message3);
Assert.AreEqual(message3, receivedMessage);
subscription1.Dispose();
publisher1.OnNext(message4);
Assert.AreEqual(message3, receivedMessage);
publisher2.OnNext(message4);
Assert.AreEqual(message4, receivedMessage);
}
public void OAPHShouldRethrowErrors()
{
var input = new Subject<int>();
var sched = new TestScheduler();
var fixture = new ObservableAsPropertyHelper<int>(input,
_ => { }, -5, sched);
Assert.Equal(-5, fixture.Value);
(new[] { 1, 2, 3, 4 }).Run(x => input.OnNext(x));
sched.Start();
Assert.Equal(4, fixture.Value);
input.OnError(new Exception("Die!"));
sched.Start();
try {
Assert.Equal(4, fixture.Value);
} catch {
return;
}
Assert.True(false, "We should've threw there");
}
private static void FinallyTestCases()
{
Demo.DisplayHeader("The Finally operator - runs an action when the observable terminates, wither gracefully or due to an error");
Console.WriteLine();
Console.WriteLine("Successful complete");
Observable.Empty<int>()
.Finally(() => Console.WriteLine("Finally Code"))
.SubscribeConsole();
Console.WriteLine();
Console.WriteLine("Error termination");
Observable.Throw<Exception>(new Exception("error"))
.Finally(() => Console.WriteLine("Finally Code"))
.SubscribeConsole();
Console.WriteLine();
Console.WriteLine("Unsubscribing");
Subject<int> subject=new Subject<int>();
var subscription =
subject.AsObservable()
.Finally(() => Console.WriteLine("Finally Code"))
.SubscribeConsole();
subscription.Dispose();
}
public Observer(Subject subject, string name, string gap)
{
this.subject = subject;
this.name = name;
this.gap = gap;
subject.Notify += Update;
}
protected AutoSuspendApplication()
{
var host = new SuspensionHost();
var launchNew = new[] { ApplicationExecutionState.ClosedByUser, ApplicationExecutionState.NotRunning, };
host.IsLaunchingNew = _launched
.Where(x => launchNew.Contains(x.PreviousExecutionState))
.Select(_ => Unit.Default);
host.IsResuming = _launched
.Where(x => x.PreviousExecutionState == ApplicationExecutionState.Terminated)
.Select(_ => Unit.Default);
var unpausing = new[] { ApplicationExecutionState.Suspended, ApplicationExecutionState.Running, };
host.IsUnpausing = _launched
.Where(x => unpausing.Contains(x.PreviousExecutionState))
.Select(_ => Unit.Default);
var shouldPersistState = new Subject<SuspendingEventArgs>();
Suspending += (o, e) => shouldPersistState.OnNext(e);
host.ShouldPersistState =
shouldPersistState.Select(x => {
var deferral = x.SuspendingOperation.GetDeferral();
return Disposable.Create(deferral.Complete);
});
var shouldInvalidateState = new Subject<Unit>();
UnhandledException += (o, e) => shouldInvalidateState.OnNext(Unit.Default);
host.ShouldInvalidateState = shouldInvalidateState;
SuspensionHost = host;
}
public void LimitSizeTo()
{
var subject = new Subject<Person>();
var scheduler = new TestScheduler();
var results = subject.ToObservableChangeSet<Person>(limitSizeTo: 100,scheduler: scheduler).AsAggregator();
var items = Enumerable.Range(1, 200).Select(i => new Person("p" + i.ToString("000"), i)).ToArray();
foreach (var person in items)
{
subject.OnNext(person);
}
scheduler.AdvanceBy(100000);
Assert.AreEqual(300, results.Messages.Count, "Should be 300 messages");
Assert.AreEqual(200, results.Messages.Sum(x => x.Adds), "Should be 200 adds");
Assert.AreEqual(100, results.Messages.Sum(x => x.Removes), "Should be 100 removes");
Assert.AreEqual(100, results.Data.Count, "Should be 1 item in the cache");
var expected = items.Skip(100).ToArray().OrderBy(p => p.Name).ToArray();
var actual = results.Data.Items.OrderBy(p => p.Name).ToArray();
CollectionAssert.AreEqual(expected, actual,"Only second hundred should be in the cache");
}
private static void DeterministicDisposal()
{
Demo.DisplayHeader("The Using operator will make sure that the resource is disposed no matter what caused the observable to stop");
Subject<int> subject = new Subject<int>();
var observable =
Observable.Using(() => Disposable.Create(() => { Console.WriteLine("DISPOSED"); }),
_ => subject);
Console.WriteLine();
Console.WriteLine("Disposed when completed");
observable.SubscribeConsole();
subject.OnCompleted();
Console.WriteLine();
Console.WriteLine("Disposed when error occurs");
subject = new Subject<int>();
observable.SubscribeConsole();
subject.OnError(new Exception("error"));
Console.WriteLine();
Console.WriteLine("Disposed when subscription disposed");
subject = new Subject<int>();
var subscription =
observable.SubscribeConsole();
subscription.Dispose();
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var cache = GetDataFolder();
using (var source = new CancellationTokenSource())
{
var builder = Sys.Configure(cache);
var fastSubject = new Subject<ISystemEvent>();
builder.Advanced.Observers.Clear();
builder.Advanced.RegisterObserver(fastSubject);
using (var host = builder.Build())
{
Console.WriteLine("Starting host");
var task = host.Start(source.Token);
var form = new Form1(host, fastSubject);
form.FormClosing += (sender, args) => source.Cancel();
Application.Run(form);
task.Wait(5000);
}
}
}
public EventService()
{
RefreshRooms = new Subject<bool>();
NotifyUnreadMessages = new Subject<IEnumerable<IMessageViewModel>>();
PushMessage = new Subject<Tuple<string, IMessageViewModel>>();
ReadRoom = new Subject<IRoomViewModel>();
}
public void UseObserverTest1()
{
var subject = new Subject<string>();
var result = new List<Tuple<int, string>>();
subject
.Select(x => new Tuple<int, string>(0, x))
.UseObserver((observer, value, i) =>
{
observer.OnNext(new Tuple<int, string>(i, value.Item2));
},
null,
observer =>
{
observer.OnNext(new Tuple<int, string>(-1, "end"));
})
.Subscribe(result.Add);
subject.OnNext("a");
subject.OnNext("b");
subject.OnNext("c");
subject.OnCompleted();
result.Is(
new Tuple<int, string>(0, "a"),
new Tuple<int, string>(1, "b"),
new Tuple<int, string>(2, "c"),
new Tuple<int, string>(-1, "end"));
}
public DayRow()
{
this.audience = new Audience();
this.teacher = "NoTeacher";
this.subject = new Subject();
this.KindOfWeek = SheduleRedactor.KindOfWeek.Numerator;
}
public BufferedHandler(TimeSpan timeDelay, int batchSize)
{
_storiesSubject = new Subject<IStory>();
_storiesSubject.Buffer(timeDelay, batchSize)
.Where(buffer => buffer.Any())
.Subscribe(OnStoriesComplete, OnComplete);
}
internal AudioPlayer()
{
this.audioPlayerCallback = new DummyMediaPlayerCallback();
this.videoPlayerCallback = new DummyMediaPlayerCallback();
this.currentCallback = new DummyMediaPlayerCallback();
this.finishSubscription = new SerialDisposable();
this.gate = new SemaphoreSlim(1, 1);
this.playbackState = new BehaviorSubject<AudioPlayerState>(AudioPlayerState.None);
this.PlaybackState = this.playbackState.DistinctUntilChanged();
this.loadedSong = new BehaviorSubject<Song>(null);
this.TotalTime = this.loadedSong.Select(x => x == null ? TimeSpan.Zero : x.Duration);
this.currentTimeChangedFromOuter = new Subject<TimeSpan>();
var conn = Observable.Interval(TimeSpan.FromMilliseconds(300), RxApp.TaskpoolScheduler)
.CombineLatest(this.PlaybackState, (l, state) => state)
.Where(x => x == AudioPlayerState.Playing)
.Select(_ => this.CurrentTime)
.Merge(this.currentTimeChangedFromOuter)
.DistinctUntilChanged(x => x.TotalSeconds)
.Publish(TimeSpan.Zero);
conn.Connect();
this.CurrentTimeChanged = conn;
}
public AutoSuspendAppDelegate()
{
var host = new SuspensionHost();
host.IsLaunchingNew = Observable.Never<Unit>();
host.IsResuming = _finishedLaunching.Select(_ => Unit.Default);
host.IsUnpausing = _activated.Select(_ => Unit.Default);
var untimelyDeath = new Subject<Unit>();
AppDomain.CurrentDomain.UnhandledException += (o,e) => untimelyDeath.OnNext(Unit.Default);
host.ShouldInvalidateState = untimelyDeath;
host.ShouldPersistState = _willTerminate.Merge(_backgrounded).SelectMany(app => {
var taskId = app.BeginBackgroundTask(new NSAction(() => untimelyDeath.OnNext(Unit.Default)));
// NB: We're being force-killed, signal invalidate instead
if (taskId == UIApplication.BackgroundTaskInvalid) {
untimelyDeath.OnNext(Unit.Default);
return Observable.Empty<IDisposable>();
}
return Observable.Return(
Disposable.Create(() => app.EndBackgroundTask(taskId)));
});
SuspensionHost = host;
}
public CurveDrawingSurface(
ICurvePool curvePool,
InputReference inputReference)
{
RenderOptions.SetBitmapScalingMode(this, BitmapScalingMode.Linear);
// Wichtig für "Pan" und "Zoom"
ClipToBounds = true;
_curvePool = curvePool;
_curvePool.CurveAdded += OnCurveAdded;
_curvePool.CurveRemoved += OnCurveRemoved;
inputReference.InputElement.MouseMove += (s, e) => HandleMouseMove(e);
inputReference.InputElement.MouseLeave += (s, e) => HandleMouseLeave(e);
inputReference.InputElement.MouseLeftButtonUp += (s, e) => HandleMouseLeftButtonUp(e);
inputReference.InputElement.MouseLeftButtonDown += (s, e) => HandleMouseLeftButtonDown(e);
inputReference.InputElement.MouseRightButtonUp += (s, e) => HandleMouseRightButtonUp(e);
inputReference.InputElement.MouseRightButtonDown += (s, e) => HandleMouseRightButtonDown(e);
_redrawSubject = new Subject<object>();
_redrawSubject
//.Skip(1)
.Throttle(TimeSpan.FromMilliseconds(50))
.Subscribe(it => _redrawEvent.Set());
_redrawThread = new Thread(RedrawThreadProc);
_redrawThread.IsBackground = true;
_redrawThread.SetApartmentState(ApartmentState.STA);
_redrawThread.Start();
}
public void values_are_taken_from_each_selected_value()
{
var stats = new StatsObserver<int>();
var source = new Subject<int>();
var first = new Subject<int>();
var second = new Subject<int>();
var remaining = new Queue<IObservable<int>>();
remaining.Enqueue(first);
remaining.Enqueue(second);
var manObs = source
.SelectMany(x => remaining.Dequeue())
.Subscribe(stats);
source.OnNext(0);
first.OnNext(1);
source.OnNext(2);
second.OnNext(3);
first.OnNext(4);
second.OnNext(5);
Assert.AreEqual(4, stats.NextCount);
Assert.AreEqual(1, stats.NextValues[0]);
Assert.AreEqual(3, stats.NextValues[1]);
Assert.AreEqual(4, stats.NextValues[2]);
Assert.AreEqual(5, stats.NextValues[3]);
}
public void NotifiesOfSegmentWhenFileIsCreated()
{
//need to make this test
var file = Path.GetTempFileName();
var info = new FileInfo(file);
var refresher = new Subject<Unit>();
var segmenter = new FileSegmenter(info.WatchFile(refresher), 1000);
FileSegmentCollection result = null;
using (var indexer = segmenter.Segments.Subscribe(segment => result = segment))
{
result.Should().NotBeNull();
File.AppendAllLines(file,
Enumerable.Range(1, 10000).Select(i => $"This is line number {i.ToString("00000000")}").ToArray());
refresher.Once();
result.Should().NotBeNull();
result.Count.Should().BeGreaterOrEqualTo(2);
result.Segments.Select(fs => fs.Type).Should().Contain(FileSegmentType.Head);
result.Segments.Select(fs => fs.Type).Should().Contain(FileSegmentType.Tail);
result.FileLength.Should().Be(info.Length);
File.AppendAllLines(file, Enumerable.Range(101, 10).Select(i => $"{i}"));
refresher.Once();
info.Refresh();
result.FileLength.Should().Be(info.Length);
File.Delete(file);
}
File.Delete(file);
}
private static void ProccessingTheSourceAndTheResult()
{
Demo.DisplayHeader("The SelectMany operator - with resultSelector you can ");
var roomsSubject = new Subject<ChatRoom>();
IObservable<ChatRoom> rooms = roomsSubject.AsObservable();
rooms
.Log("Rooms")
.SelectMany(r => r.Messages,
(room, msg) => new ChatMessageViewModel(msg) {Room = room.Id})
.Subscribe(vm => AddToDashboard(vm));
var room1 = new Subject<ChatMessage>();
roomsSubject.OnNext(new ChatRoom { Id = "Room1", Messages = room1 });
room1.OnNext(new ChatMessage { Content = "First Message", Sender = "1" });
room1.OnNext(new ChatMessage { Content = "Second Message", Sender = "1" });
var room2 = new Subject<ChatMessage>();
roomsSubject.OnNext(new ChatRoom { Id = "Room2", Messages = room2 });
room2.OnNext(new ChatMessage { Content = "Hello World", Sender = "2" });
room1.OnNext(new ChatMessage { Content = "Another Message", Sender = "1" });
}
/// <summary>
/// Initializes a new instance of the <see cref="SuspensionService"/> class.
/// Based on WinRTSuspensionHost in ReactiveUI.Mobile
/// </summary>
public SuspensionService(Application app, ISubject<LaunchActivatedEventArgs> launched)
{
var launchNew = new[] { ApplicationExecutionState.ClosedByUser, ApplicationExecutionState.NotRunning, };
this.IsLaunchingNew = launched
.Where(x => launchNew.Contains(x.PreviousExecutionState))
.Select(x => x.Arguments);
this.IsResuming = launched
.Where(x => x.PreviousExecutionState == ApplicationExecutionState.Terminated)
.Select(x => x.Arguments);
var unpausing = new[] { ApplicationExecutionState.Suspended, ApplicationExecutionState.Running, };
this.IsUnpausing = launched
.Where(x => unpausing.Contains(x.PreviousExecutionState))
.Select(x => x.Arguments);
var shouldPersistState = new Subject<SuspendingEventArgs>();
app.Suspending += (o, e) => shouldPersistState.OnNext(e);
this.ShouldPersistState =
shouldPersistState.Select(x =>
{
var deferral = x.SuspendingOperation.GetDeferral();
return Disposable.Create(deferral.Complete);
});
var shouldInvalidateState = new Subject<Unit>();
app.UnhandledException += (o, e) => shouldInvalidateState.OnNext(Unit.Default);
this.ShouldInvalidateState = shouldInvalidateState;
}
public AskActorReq(object msg, Subject<object> subject, ProcessId to, ProcessId replyTo)
{
Message = msg;
Subject = subject;
To = to;
ReplyTo = replyTo;
}
private static void FlatenningObservableOfObservables()
{
Demo.DisplayHeader("The SelectMany operator - flattening observables of message to one stream of messages");
var roomsSubject = new Subject<ChatRoom>();
IObservable<ChatRoom> rooms = roomsSubject.AsObservable();
rooms
.Log("Rooms")
.SelectMany(r => r.Messages)
.Select(m => new ChatMessageViewModel(m))
.Subscribe(vm => AddToDashboard(vm));
//
// This is how the same example would look without SelectMany
//
//rooms
// .Log("Rooms")
// .Select(r => r.Messages)
// .Select(messages => messages.Select(m => new ChatMessageViewModel(m)))
// .Subscribe(roomMessages => roomMessages.Subscribe(m => AddToDashboard(m)));
var room1 = new Subject<ChatMessage>();
roomsSubject.OnNext(new ChatRoom {Id = "Room1", Messages = room1.Do(m => m.Room = "Room1")});
room1.OnNext(new ChatMessage {Content = "First Message", Sender = "1"});
room1.OnNext(new ChatMessage {Content = "Second Message", Sender = "1"});
var room2 = new Subject<ChatMessage>();
roomsSubject.OnNext(new ChatRoom {Id = "Room2", Messages = room2.Do(m => m.Room = "Room2")});
room2.OnNext(new ChatMessage {Content = "Hello World", Sender = "2"});
room1.OnNext(new ChatMessage {Content = "Another Message", Sender = "1"});
}
public void ObservableCanExecuteShouldShowUpInCommand()
{
var input = new[] {true, false, false, true, false, true};
var result = (new TestScheduler()).With(sched => {
var can_execute = new Subject<bool>();
var fixture = createCommand(can_execute, sched);
var changes_as_observable = fixture.CanExecuteObservable.CreateCollection();
int change_event_count = 0;
fixture.CanExecuteChanged += (o, e) => { change_event_count++; };
input.Run(x => {
can_execute.OnNext(x);
sched.Start();
Assert.Equal(x, fixture.CanExecute(null));
});
// N.B. We check against '5' instead of 6 because we're supposed to
// suppress changes that aren't actually changes i.e. false => false
sched.AdvanceToMs(10*1000);
return changes_as_observable;
});
// NB: Skip(1) is because CanExecuteObservable should have
// BehaviorSubject Nature(tm)
input.DistinctUntilChanged().AssertAreEqual(result.Skip(1).ToList());
}
public void ZipMulti()
{
var a = new Subject<int>();
var b = new Subject<int>();
a.OnNext(10);
b.OnNext(20);
var l = Enumerable.Empty<Unit>().Select(_ => Notification.CreateOnNext(new { x = 0, y = 0 })).ToList();
Observable.Zip(a, b).Select(xs => new { x = xs[0], y = xs[1] }).Materialize().Subscribe(x => l.Add(x));
a.OnNext(1000);
b.OnNext(2000);
a.OnCompleted();
l.Count.Is(1); // OnNext
a.OnNext(1001);
l.Count.Is(1);
b.OnNext(5);
l.Count.Is(2); // Completed!
l[1].Kind.Is(NotificationKind.OnCompleted);
}
public void BasicExperiment()
{
var xs = new Subject<int>();
var ys = new Subject<int>();
var zs = new Subject<int>();
IObservable<int> query = xs.AsOperational() + ys - zs;
using (query.Subscribe(ConsoleOutput))
{
xs.OnNext(1);
ys.OnNext(5);
zs.OnNext(2);
xs.OnNext(2);
ys.OnNext(6);
zs.OnNext(3);
xs.OnNext(3);
xs.OnNext(4);
zs.OnNext(4);
zs.OnNext(5);
ys.OnNext(7);
ys.OnNext(8);
WaitForKey();
}
}
public void AdvancedExperiment()
{
var xs = new Subject<int>();
var ys = new Subject<int>();
var zs = new Subject<int>();
// Define an operational factory so that operators are only specified once.
var o = (Func<IObservable<int>, OperationalObservable<int>>)
(source => source.AsOperational(
add: (left, right) => left + (right * 5),
subtract: (left, right) => left - right,
multiply: (left, right) => left * right,
divide: (left, right) => (left * 2) / right,
negative: value => -value));
IObservable<int> query = (-o(xs) * 2) + ys - (o(zs) / 4);
using (query.Subscribe(ConsoleOutput))
{
xs.OnNext(1);
ys.OnNext(5);
zs.OnNext(4);
xs.OnNext(2);
ys.OnNext(6);
zs.OnNext(8);
xs.OnNext(3);
ys.OnNext(7);
zs.OnNext(12);
WaitForKey();
}
}
public void CombineLatest()
{
var a = new Subject<int>();
var b = new Subject<int>();
a.OnNext(10);
b.OnNext(20);
var l = Enumerable.Empty<Unit>().Select(_ => Notification.CreateOnNext(new { x = 0, y = 0 })).ToList();
a.CombineLatest(b, (x, y) => new { x, y }).Materialize().Subscribe(x => l.Add(x));
a.OnNext(1000);
b.OnNext(2000);
l[0].Value.Is(new { x = 1000, y = 2000 });
b.OnNext(3000);
l[1].Value.Is(new { x = 1000, y = 3000 });
a.OnNext(5000);
l[2].Value.Is(new { x = 5000, y = 3000 });
a.OnCompleted();
l.Count.Is(3);
a.OnNext(1001);
l.Count.Is(3);
b.OnNext(5);
l[3].Value.Is(new { x = 5000, y = 5 });
b.OnNext(500);
l[4].Value.Is(new { x = 5000, y = 500 });
b.OnCompleted();
l[5].Kind.Is(NotificationKind.OnCompleted);
}
static void Main(string[] args)
{
Subject<int> numbers = new Subject<int>();
var historicalScheduler = new System.Reactive.Concurrency.HistoricalScheduler(new DateTime(2015, 11, 21, 17, 10, 0));
historicalScheduler.Schedule(new DateTime(2015, 11, 21, 17, 10, 0), () => numbers.OnNext(1));
historicalScheduler.Schedule(new DateTime(2015, 11, 21, 17, 11, 0), () => numbers.OnNext(2));
historicalScheduler.Schedule(new DateTime(2015, 11, 21, 17, 32, 0), () => numbers.OnNext(3));
historicalScheduler.Schedule(new DateTime(2015, 11, 21, 17, 39, 0), () => numbers.OnNext(4));
historicalScheduler.Schedule(new DateTime(2015, 11, 21, 17, 51, 0), () => historicalScheduler.Stop());
numbers.AsObservable()
.Buffer(TimeSpan.FromMinutes(20), historicalScheduler)
.Subscribe(buffer =>
{
Console.WriteLine("time is: {0}", historicalScheduler.Now);
Console.WriteLine("Buffer:");
foreach (var x in buffer)
{
Console.WriteLine("\t{0}", x);
}
});
historicalScheduler.Start();
Console.WriteLine("Press <enter> to continue");
Console.ReadLine();
}
public AutoSuspendHelper(UIApplicationDelegate appDelegate)
{
Reflection.ThrowIfMethodsNotOverloaded("AutoSuspendHelper", appDelegate,
"FinishedLaunching", "OnActivated", "DidEnterBackground");
RxApp.SuspensionHost.IsLaunchingNew = Observable.Never<Unit>();
RxApp.SuspensionHost.IsResuming = _finishedLaunching.Select(_ => Unit.Default);
RxApp.SuspensionHost.IsUnpausing = _activated.Select(_ => Unit.Default);
var untimelyDeath = new Subject<Unit>();
AppDomain.CurrentDomain.UnhandledException += (o,e) => untimelyDeath.OnNext(Unit.Default);
RxApp.SuspensionHost.ShouldInvalidateState = untimelyDeath;
RxApp.SuspensionHost.ShouldPersistState = _backgrounded.SelectMany(app => {
var taskId = app.BeginBackgroundTask(new NSAction(() => untimelyDeath.OnNext(Unit.Default)));
// NB: We're being force-killed, signal invalidate instead
if (taskId == UIApplication.BackgroundTaskInvalid) {
untimelyDeath.OnNext(Unit.Default);
return Observable.Empty<IDisposable>();
}
return Observable.Return(Disposable.Create(() => app.EndBackgroundTask(taskId)));
});
}
public void Main()
{
var subject = new Subject();
var Observer = new Observer(subject, "Center", "\t\t");
var observer2 = new Observer(subject, "Right", "\t\t\t\t");
subject.Go();
}
public void EigenUpdateWithoutUpdateURL()
{
string dir;
string outDir;
using (Utility.WithTempDirectory(out outDir))
using (IntegrationTestHelper.WithFakeInstallDirectory(out dir)) {
var di = new DirectoryInfo(dir);
var progress = new Subject<int>();
var bundledRelease = ReleaseEntry.GenerateFromFile(di.GetFiles("*.nupkg").First().FullName);
var fixture = new InstallManager(bundledRelease, outDir);
var pkg = new ZipPackage(Path.Combine(dir, "SampleUpdatingApp.1.1.0.0.nupkg"));
var progressValues = new List<int>();
progress.Subscribe(progressValues.Add);
fixture.ExecuteInstall(dir, pkg, progress).Wait();
var filesToLookFor = new[] {
"SampleUpdatingApp\\app-1.1.0.0\\SampleUpdatingApp.exe",
"SampleUpdatingApp\\packages\\RELEASES",
"SampleUpdatingApp\\packages\\SampleUpdatingApp.1.1.0.0.nupkg",
};
filesToLookFor.ForEach(f => Assert.True(File.Exists(Path.Combine(outDir, f)), "Could not find file: " + f));
// Progress should be monotonically increasing
progressValues.Count.ShouldBeGreaterThan(2);
progressValues.Zip(progressValues.Skip(1), (prev, cur) => cur - prev).All(x => x > 0).ShouldBeTrue();
}
}
public void GetProcessById_should_return_null_for_invalid_process(int processId)
{
Subject.GetProcessById(processId).Should().BeNull();
ExceptionVerification.ExpectedWarns(1);
}
public void should_throw_with_id_if_not_exist()
{
var id = 123;
Assert.Throws <ModelNotFoundException>(() => Subject.GetByQualityId(id)).Message.Contains(id.ToString());
}
public void should_get_qualitydefinition_by_id()
{
var size = Subject.GetByQualityId((int)Quality.Bluray1080p);
size.Should().NotBeNull();
}
public void should_throw_for_non_success()
{
Mocker.Use <IUserAgentBuilder>(new UserAgentBuilder(new EnvInfo()));
Assert.ThrowsAsync <HttpException>(async() => await Subject.GetAsync(new Uri("https://google.com/not-a-valid-path"), TimeSpan.FromSeconds(10)));
}
public void Update(Subject subject)
{
subjectStorage.Update(subject);
}
public Subject Add(Subject subject)
{
return(subjectStorage.Add(subject));
}
private Process StartDummyProcess()
{
return Subject.Start(DummyApp.DUMMY_PROCCESS_NAME + ".exe");
}
public IObservable <Unit> OnBlocTouchAsObservable()
{
return(onBlocTouch ?? (onBlocTouch = new Subject <Unit>()));
}
public void should_not_return_error_when_no_indexers()
{
Subject.Check().ShouldBeOk();
}
public void GetById_should_return_null_if_process_doesnt_exist()
{
Subject.GetProcessById(1234567).Should().BeNull();
ExceptionVerification.ExpectedWarns(1);
}
public void should_return_null_hash()
{
var remoteBook = CreateRemoteBook();
Subject.Download(remoteBook).Should().BeNull();
}
public void should_return_error_if_all_indexers_unavailable()
{
GivenIndexer(1, 10.0, 24.0);
Subject.Check().ShouldBeError();
}
public void should_not_follow_redirects_when_not_in_production(HttpStatusCode statusCode)
{
var request = new HttpRequest("http://eu.httpbin.org/status/" + (int)statusCode);
Assert.Throws <Exception>(() => Subject.Get <HttpBinResource>(request));
}
public IObservable <T[]> OnUpdateContentsAsObservable()
{
return(onUpdateContents ?? (onUpdateContents = new Subject <T[]>()));
}
public override IDeepCopyable CopyTo(IDeepCopyable other)
{
var dest = other as DeviceRequest;
if (dest == null)
{
throw new ArgumentException("Can only copy to an object of the same type", "other");
}
base.CopyTo(dest);
if (Identifier != null)
{
dest.Identifier = new List <Hl7.Fhir.Model.Identifier>(Identifier.DeepCopy());
}
if (InstantiatesCanonicalElement != null)
{
dest.InstantiatesCanonicalElement = new List <Hl7.Fhir.Model.Canonical>(InstantiatesCanonicalElement.DeepCopy());
}
if (InstantiatesUriElement != null)
{
dest.InstantiatesUriElement = new List <Hl7.Fhir.Model.FhirUri>(InstantiatesUriElement.DeepCopy());
}
if (BasedOn != null)
{
dest.BasedOn = new List <Hl7.Fhir.Model.ResourceReference>(BasedOn.DeepCopy());
}
if (PriorRequest != null)
{
dest.PriorRequest = new List <Hl7.Fhir.Model.ResourceReference>(PriorRequest.DeepCopy());
}
if (GroupIdentifier != null)
{
dest.GroupIdentifier = (Hl7.Fhir.Model.Identifier)GroupIdentifier.DeepCopy();
}
if (StatusElement != null)
{
dest.StatusElement = (Code <Hl7.Fhir.Model.RequestStatus>)StatusElement.DeepCopy();
}
if (IntentElement != null)
{
dest.IntentElement = (Code <Hl7.Fhir.Model.RequestIntent>)IntentElement.DeepCopy();
}
if (PriorityElement != null)
{
dest.PriorityElement = (Code <Hl7.Fhir.Model.RequestPriority>)PriorityElement.DeepCopy();
}
if (Code != null)
{
dest.Code = (Hl7.Fhir.Model.CodeableReference)Code.DeepCopy();
}
if (Parameter != null)
{
dest.Parameter = new List <Hl7.Fhir.Model.DeviceRequest.ParameterComponent>(Parameter.DeepCopy());
}
if (Subject != null)
{
dest.Subject = (Hl7.Fhir.Model.ResourceReference)Subject.DeepCopy();
}
if (Encounter != null)
{
dest.Encounter = (Hl7.Fhir.Model.ResourceReference)Encounter.DeepCopy();
}
if (Occurrence != null)
{
dest.Occurrence = (Hl7.Fhir.Model.DataType)Occurrence.DeepCopy();
}
if (AuthoredOnElement != null)
{
dest.AuthoredOnElement = (Hl7.Fhir.Model.FhirDateTime)AuthoredOnElement.DeepCopy();
}
if (Requester != null)
{
dest.Requester = (Hl7.Fhir.Model.ResourceReference)Requester.DeepCopy();
}
if (PerformerType != null)
{
dest.PerformerType = (Hl7.Fhir.Model.CodeableConcept)PerformerType.DeepCopy();
}
if (Performer != null)
{
dest.Performer = (Hl7.Fhir.Model.ResourceReference)Performer.DeepCopy();
}
if (Reason != null)
{
dest.Reason = new List <Hl7.Fhir.Model.CodeableReference>(Reason.DeepCopy());
}
if (Insurance != null)
{
dest.Insurance = new List <Hl7.Fhir.Model.ResourceReference>(Insurance.DeepCopy());
}
if (SupportingInfo != null)
{
dest.SupportingInfo = new List <Hl7.Fhir.Model.ResourceReference>(SupportingInfo.DeepCopy());
}
if (Note != null)
{
dest.Note = new List <Hl7.Fhir.Model.Annotation>(Note.DeepCopy());
}
if (RelevantHistory != null)
{
dest.RelevantHistory = new List <Hl7.Fhir.Model.ResourceReference>(RelevantHistory.DeepCopy());
}
return(dest);
}
public ActionResult Create(Subject subject)
{
SubjectStorage.Add(subject);
return(RedirectToAction("Index"));
}
/// <summary>OnBecameVisible is called when the renderer became visible by any camera.</summary>
public IObservable <Unit> OnBecameVisibleAsObservable()
{
return(onBecameVisible ?? (onBecameVisible = new Subject <Unit>()));
}
public Service()
{
_timesubject = new Subject <int>();
}
public void ToReadOnlyReactivePropertyValueType()
{
{
var source = new Subject <int>();
var rp = source.ToReadOnlyReactiveProperty();
var result = rp.Record();
result.Values.Count.Is(0);
source.OnNext(0);
result.Values.Is(0);
source.OnNext(10);
result.Values.Is(0, 10);
source.OnNext(100);
result.Values.Is(0, 10, 100);
source.OnNext(100);
result.Values.Is(0, 10, 100);
}
{
var source = new Subject <int>();
var rp = source.ToSequentialReadOnlyReactiveProperty();
var result = rp.Record();
result.Values.Count.Is(0);
source.OnNext(0);
result.Values.Is(0);
source.OnNext(10);
result.Values.Is(0, 10);
source.OnNext(100);
result.Values.Is(0, 10, 100);
source.OnNext(100);
result.Values.Is(0, 10, 100, 100);
}
{
var source = new Subject <int>();
var rp = source.ToReadOnlyReactiveProperty(0);
var result = rp.Record();
result.Values.Is(0);
source.OnNext(0);
result.Values.Is(0);
source.OnNext(10);
result.Values.Is(0, 10);
source.OnNext(100);
result.Values.Is(0, 10, 100);
source.OnNext(100);
result.Values.Is(0, 10, 100);
}
{
var source = new Subject <int>();
var rp = source.ToSequentialReadOnlyReactiveProperty(0);
var result = rp.Record();
result.Values.Is(0);
source.OnNext(0);
result.Values.Is(0, 0);
source.OnNext(10);
result.Values.Is(0, 0, 10);
source.OnNext(100);
result.Values.Is(0, 0, 10, 100);
source.OnNext(100);
result.Values.Is(0, 0, 10, 100, 100);
}
}
public NBAObserver(string name, Subject sub)
{
this.name = name;
this.sub = sub;
}
public UniRx.IObservable <Unit> UpdateAsObservable()
{
return(update ?? (update = new Subject <Unit>()));
}
public void ToReadOnlyReactivePropertyClassType()
{
{
var source = new Subject <string>();
var rp = source.ToReadOnlyReactiveProperty();
var result = rp.Record();
result.Values.Count.Is(0);
source.OnNext(null);
result.Values.Is((string)null);
source.OnNext("a");
result.Values.Is((string)null, "a");
source.OnNext("b");
result.Values.Is((string)null, "a", "b");
source.OnNext("b");
result.Values.Is((string)null, "a", "b");
}
{
var source = new Subject <string>();
var rp = source.ToSequentialReadOnlyReactiveProperty();
var result = rp.Record();
result.Values.Count.Is(0);
source.OnNext(null);
result.Values.Is((string)null);
source.OnNext("a");
result.Values.Is((string)null, "a");
source.OnNext("b");
result.Values.Is((string)null, "a", "b");
source.OnNext("b");
result.Values.Is((string)null, "a", "b", "b");
}
{
var source = new Subject <string>();
var rp = source.ToReadOnlyReactiveProperty("z");
var result = rp.Record();
result.Values.Is("z");
source.OnNext("z");
result.Values.Is("z");
source.OnNext("a");
result.Values.Is("z", "a");
source.OnNext("b");
result.Values.Is("z", "a", "b");
source.OnNext("b");
result.Values.Is("z", "a", "b");
source.OnNext(null);
result.Values.Is("z", "a", "b", null);
source.OnNext(null);
result.Values.Is("z", "a", "b", null);
}
{
var source = new Subject <string>();
var rp = source.ToSequentialReadOnlyReactiveProperty("z");
var result = rp.Record();
result.Values.Is("z");
source.OnNext("z");
result.Values.Is("z", "z");
source.OnNext("a");
result.Values.Is("z", "z", "a");
source.OnNext("b");
result.Values.Is("z", "z", "a", "b");
source.OnNext("b");
result.Values.Is("z", "z", "a", "b", "b");
source.OnNext(null);
result.Values.Is("z", "z", "a", "b", "b", null);
source.OnNext(null);
result.Values.Is("z", "z", "a", "b", "b", null, null);
}
}
/// <summary>Sent each frame where another object is within a trigger collider attached to this object (2D physics only).</summary>
public IObservable <Collider2D> OnTriggerStay2DAsObservable()
{
return(onTriggerStay2D ?? (onTriggerStay2D = new Subject <Collider2D>()));
}
public override IDeepCopyable CopyTo(IDeepCopyable other)
{
var dest = other as Invoice;
if (dest == null)
{
throw new ArgumentException("Can only copy to an object of the same type", "other");
}
base.CopyTo(dest);
if (Identifier != null)
{
dest.Identifier = new List <Hl7.Fhir.Model.Identifier>(Identifier.DeepCopy());
}
if (StatusElement != null)
{
dest.StatusElement = (Code <Hl7.Fhir.Model.Invoice.InvoiceStatus>)StatusElement.DeepCopy();
}
if (CancelledReasonElement != null)
{
dest.CancelledReasonElement = (Hl7.Fhir.Model.FhirString)CancelledReasonElement.DeepCopy();
}
if (Type != null)
{
dest.Type = (Hl7.Fhir.Model.CodeableConcept)Type.DeepCopy();
}
if (Subject != null)
{
dest.Subject = (Hl7.Fhir.Model.ResourceReference)Subject.DeepCopy();
}
if (Recipient != null)
{
dest.Recipient = (Hl7.Fhir.Model.ResourceReference)Recipient.DeepCopy();
}
if (DateElement != null)
{
dest.DateElement = (Hl7.Fhir.Model.FhirDateTime)DateElement.DeepCopy();
}
if (Participant != null)
{
dest.Participant = new List <Hl7.Fhir.Model.Invoice.ParticipantComponent>(Participant.DeepCopy());
}
if (Issuer != null)
{
dest.Issuer = (Hl7.Fhir.Model.ResourceReference)Issuer.DeepCopy();
}
if (Account != null)
{
dest.Account = (Hl7.Fhir.Model.ResourceReference)Account.DeepCopy();
}
if (LineItem != null)
{
dest.LineItem = new List <Hl7.Fhir.Model.Invoice.LineItemComponent>(LineItem.DeepCopy());
}
if (TotalPriceComponent != null)
{
dest.TotalPriceComponent = new List <Hl7.Fhir.Model.Invoice.PriceComponentComponent>(TotalPriceComponent.DeepCopy());
}
if (TotalNet != null)
{
dest.TotalNet = (Hl7.Fhir.Model.Money)TotalNet.DeepCopy();
}
if (TotalGross != null)
{
dest.TotalGross = (Hl7.Fhir.Model.Money)TotalGross.DeepCopy();
}
if (PaymentTerms != null)
{
dest.PaymentTerms = (Hl7.Fhir.Model.Markdown)PaymentTerms.DeepCopy();
}
if (Note != null)
{
dest.Note = new List <Hl7.Fhir.Model.Annotation>(Note.DeepCopy());
}
return(dest);
}
public void SetMark(Subject subject, Mark mark)
{
throw new NotImplementedException();
}
public void Update(Subject subject)
{
Console.WriteLine($"ILS updated, current {this.USDMoney} and new {this.USDMoney + subject.Money}");
this.USDMoney += subject.Money;
}
public GeofenceManagerDelegate()
{
this.repository = ShinyHost.Resolve <IRepository>().Wrap();
this.stateSubject = new Subject <GeofenceCurrentStatus>();
}
public void should_search_for_series_using_folder_name()
{
Subject.ProcessRootFolder(new DirectoryInfo(_droneFactory));
Mocker.GetMock <IParsingService>().Verify(c => c.GetSeries("foldername"), Times.Once());
}
public void Where()
{
{
var a = new Subject<int>();
var list = new List<int>();
a.Where(x => x % 3 == 0).Subscribe(x => list.Add(x));
a.OnNext(3);
a.OnNext(5);
a.OnNext(7);
a.OnNext(9);
a.OnNext(300);
a.OnCompleted();
list.IsCollection(3, 9, 300);
}
{
var a = new Subject<int>();
var list = new List<int>();
a.Where((x, i) => (x + i) % 3 == 0).Subscribe(x => list.Add(x));
a.OnNext(3); // 3 + 0
a.OnNext(5); // 5 + 1
a.OnNext(7); // 7 + 2
a.OnNext(9); // 9 + 3
a.OnNext(300); // 300 + 4
a.OnCompleted();
list.IsCollection(3, 5, 7, 9);
}
{
var a = new Subject<int>();
var list = new List<int>();
a.Where(x => x % 3 == 0).Where(x => x % 5 == 0).Subscribe(x => list.Add(x));
a.OnNext(3);
a.OnNext(5);
a.OnNext(7);
a.OnNext(9);
a.OnNext(300);
a.OnCompleted();
list.IsCollection(300);
}
{
var a = new Subject<int>();
var list = new List<int>();
a.Where((x, i) => (x + i) % 3 == 0).Where(x => x % 5 == 0).Subscribe(x => list.Add(x));
a.OnNext(3); // 3 + 0
a.OnNext(5); // 5 + 1
a.OnNext(7); // 7 + 2
a.OnNext(9); // 9 + 3
a.OnNext(300); // 300 + 4
a.OnCompleted();
list.IsCollection(5);
}
}
public Mark GetMark(Subject subject)
{
throw new NotImplementedException();
}
