public void Mapper_Crash()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
var to = ReactiveExtensions.CombineLatest(a =>
{
int v = 0;
foreach (var e in a)
{
v += e;
}
if (v == 22)
{
throw new InvalidOperationException();
}
return(v);
}, us1, us2).Test();
to.AssertEmpty();
us1.OnNext(1);
us2.OnNext(10);
us1.OnNext(2);
us2.OnNext(20);
Assert.False(us1.HasObserver());
Assert.False(us2.HasObserver());
to.AssertFailure(typeof(InvalidOperationException), 11, 12);
}
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 Error_Delayed()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
var to = ReactiveExtensions.CombineLatest(a =>
{
int v = 0;
foreach (var e in a)
{
v += e;
}
return(v);
}, true, us1, us2).Test();
to.AssertEmpty();
us1.OnNext(1);
us1.OnError(new InvalidOperationException());
Assert.True(us2.HasObserver());
us2.EmitAll(10, 20, 30, 40, 50);
to.AssertFailure(typeof(InvalidOperationException), 11, 21, 31, 41, 51);
}
public void Error_Delayed()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
var to = ReactiveExtensions.Zip(a =>
{
int s = 0;
foreach (var v in a)
{
s += v;
}
return(s);
}, true,
us1,
us2
).Test();
us1.EmitError(new InvalidOperationException(), 1, 2, 3);
Assert.True(us2.HasObserver(), "us2: No observers!");
us2.Emit(10, 20, 30, 40);
Assert.False(us2.HasObserver(), "us2: Observers present!");
to.AssertFailure(typeof(InvalidOperationException), 11, 22, 33);
}
public void No_Combinations_Complete_After_All()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
var to = ReactiveExtensions.CombineLatest(a =>
{
int v = 0;
foreach (var e in a)
{
v += e;
}
return(v);
}, us1, us2).Test();
to.AssertEmpty();
us1.OnCompleted();
Assert.True(us2.HasObserver(), "Other source disposed?");
us2.EmitAll(1, 2, 3, 4, 5);
to.AssertResult();
}
public void Mapper_Crashes()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
var to = ReactiveExtensions.Zip(a =>
{
int s = 0;
foreach (var v in a)
{
s += v;
}
if (s == 33)
{
throw new InvalidOperationException();
}
return(s);
},
us1,
us2
).Test();
us1.Emit(1, 2, 3);
Assert.True(us1.HasObserver());
Assert.True(us2.HasObserver());
us2.Emit(10, 20, 30, 40);
Assert.False(us1.HasObserver());
Assert.False(us2.HasObserver());
to.AssertFailure(typeof(InvalidOperationException), 11, 22);
}
public void ObserveCommand_should_register_a_delegate_command_handler()
{
Mock <IBusBuilder> mockBusBuilder = new Mock <IBusBuilder>();
var observable = ReactiveExtensions.ObserveCommand <TestCommand>(mockBusBuilder.Object);
mockBusBuilder.Verify(p => p.SubscribeToCommand(It.IsAny <Func <CommandContext <TestCommand>, Task> >()), Times.Once);
}
public void ObserveEvent_should_register_a_delegate_event_handler()
{
Mock <IBusBuilder> mockBusBuilder = new Mock <IBusBuilder>();
var observable = ReactiveExtensions.ObserveEvent <TestEvent>(mockBusBuilder.Object);
mockBusBuilder.Verify(p => p.SubscribeToEvent(It.IsAny <Func <EventContext <TestEvent>, Task> >()), Times.Once);
}
public void Basic_With_Error()
{
var up = new UnicastSubject <int>();
var to = new TestObserver <int>();
up.Subscribe(ReactiveExtensions.ToSerialized(to));
up.EmitError(new InvalidOperationException(), 1, 2, 3, 4, 5);
to.AssertFailure(typeof(InvalidOperationException), 1, 2, 3, 4, 5);
}
public void Basic()
{
var up = new UnicastSubject <int>();
var to = new TestObserver <int>();
up.Subscribe(ReactiveExtensions.ToSerialized(to));
up.EmitAll(1, 2, 3, 4, 5);
to.AssertResult(1, 2, 3, 4, 5);
}
public override void Execute(object parameter)
{
SearchForIssuesDialog dlg = new SearchForIssuesDialog();
dlg.Owner = SD.Workbench.MainWindow;
if (dlg.ShowDialog() == true)
{
string title = "Issue Search";
var providers = dlg.SelectedProviders.ToList();
var fileNames = GetFilesToSearch(dlg.Target).ToList();
if (dlg.FixIssues)
{
int fixedIssueCount = 0;
IReadOnlyList <SearchResultMatch> remainingIssues = null;
AsynchronousWaitDialog.RunInCancellableWaitDialog(
title, null,
monitor => {
remainingIssues = FindAndFixIssues(fileNames, providers, monitor, out fixedIssueCount);
});
if (remainingIssues == null)
{
return; // can happen if issue search is cancelled
}
string message = string.Format(
"{0} issues were fixed automatically." +
"{1} issues are remaining (no automatic fix available).",
fixedIssueCount, remainingIssues.Count);
SearchResultsPad.Instance.ShowSearchResults(title, remainingIssues);
MessageService.ShowMessage(message, title);
}
else if (Keyboard.Modifiers == (ModifierKeys.Control | ModifierKeys.Alt | ModifierKeys.Shift))
{
// Ctrl+Alt+Shift => run issue search on main thread,
// this helps debugging as exceptions don't get caught and passed from one thread to another
List <SearchResultMatch> issues = new List <SearchResultMatch>();
AsynchronousWaitDialog.RunInCancellableWaitDialog(
title, null,
monitor => SearchForIssues(fileNames, providers, f => issues.AddRange(f.Matches), monitor)
);
SearchResultsPad.Instance.ShowSearchResults(title, issues);
}
else
{
var monitor = SD.StatusBar.CreateProgressMonitor();
var observable = ReactiveExtensions.CreateObservable <SearchedFile>(
(m, c) => SearchForIssuesAsync(fileNames, providers, c, m),
monitor);
SearchResultsPad.Instance.ShowSearchResults(title, observable);
}
}
}
public void Disposed_Serialized()
{
var sad = new SingleAssignmentDisposable();
ReactiveExtensions.Create <int>(emitter =>
{
emitter.SetResource(sad);
}, true)
.Test()
.Cancel()
.AssertEmpty();
Assert.True(sad.IsDisposed());
}
public DragPanel()
{
CanBeFocused = false;
// Update layout when the width or height is changed.
ReactiveExtensions.MergeEvents(
WidthChanged,
HeightChanged
).Subscribe(_ => UpdateLayout());
// Update layout when a child changes its preferred width or height.
ReactiveExtensions.MergeEvents(
Children.ObserveEach(child => child.PreferredWidthChanged),
Children.ObserveEach(child => child.PreferredHeightChanged)
).Subscribe(_ => UpdateLayout());
Children.ObserveEach(c => c.MouseEventOccured).Subscribe(e =>
{
if (e.Value.Id == MouseEvent.MOUSE_PRESSED)
{
// Start drag
StartDrag(e.Element, e.Element.TranslatePointTo(this, e.Value.MousePosition));
}
else if (e.Value.Id == MouseEvent.MOUSE_DRAGGED)
{
// Apply drag
var mousePosition = e.Element.TranslatePointTo(this, e.Value.MousePosition);
double deltaX = mousePosition.X - _previousCursorPosition.X;
double deltaY = mousePosition.Y - _previousCursorPosition.Y;
ApplyDrag(e.Element, deltaX, deltaY);
_previousCursorPosition = mousePosition;
e.Value.IsHandled = true;
}
else if (e.Value.Id == MouseEvent.MOUSE_RELEASED)
{
if (_childBeingDragged != null)
{
// Finish drag
_childBeingDragged.ReleaseMouseAtRoot();
_onDragFinished.OnNext(_childBeingDragged);
_childBeingDragged = null;
e.Value.IsHandled = true;
}
}
});
}
public void Second_Shorter()
{
ReactiveExtensions.Zip(a =>
{
int s = 0;
foreach (var v in a)
{
s += v;
}
return(s);
},
Observable.Range(1, 5),
Observable.Range(10, 4)
).Test()
.AssertResult(10 + 1, 11 + 2, 12 + 3, 13 + 4);
}
public void Basic_DelayErrors()
{
ReactiveExtensions.Zip(a =>
{
int s = 0;
foreach (var v in a)
{
s += v;
}
return(s);
}, true,
Observable.Range(1, 5),
Observable.Range(10, 5)
).Test()
.AssertResult(10 + 1, 11 + 2, 12 + 3, 13 + 4, 14 + 5);
}
public void Basic()
{
var ts = new TestScheduler();
var to = ReactiveExtensions
.IntervalRange(0, 5, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2), ts)
.Test();
to.AssertEmpty();
ts.RunAll();
to.AssertResult(0, 1, 2, 3, 4);
Assert.False(ts.HasTasks());
}
public void Race()
{
for (int j = 0; j < TestHelper.RACE_LOOPS; j++)
{
var sad = new SingleAssignmentDisposable();
var to = ReactiveExtensions.Create <int>(emitter =>
{
emitter.SetResource(sad);
TestHelper.Race(() =>
{
for (int i = 0; i < 1000; i++)
{
if (emitter.IsDisposed())
{
return;
}
emitter.OnNext(i);
}
emitter.OnCompleted();
},
() =>
{
for (int i = 1000; i < 2000; i++)
{
if (emitter.IsDisposed())
{
return;
}
emitter.OnNext(i);
}
emitter.OnCompleted();
});
}, true)
.Test()
;
Assert.True(to.ItemCount >= 500, "" + to.ItemCount);
to.AssertCompleted()
.AssertNoError();
Assert.True(sad.IsDisposed());
}
}
public void Basic()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
var to = ReactiveExtensions.CombineLatest(a =>
{
int v = 0;
foreach (var e in a)
{
v += e;
}
return(v);
}, us1, us2).Test();
to.AssertEmpty();
us1.OnNext(1);
to.AssertEmpty();
us1.OnNext(2);
to.AssertEmpty();
us2.OnNext(10);
to.AssertValuesOnly(12);
us2.OnNext(20);
to.AssertValuesOnly(12, 22);
us2.OnCompleted();
to.AssertValuesOnly(12, 22);
us1.OnNext(3);
to.AssertValuesOnly(12, 22, 23);
us1.OnCompleted();
to.AssertResult(12, 22, 23);
}
public void Handler_Crash()
{
var sad = new SingleAssignmentDisposable();
ReactiveExtensions.Create <int>(emitter =>
{
emitter.SetResource(sad);
for (int i = 1; i < 6; i++)
{
emitter.OnNext(i);
}
throw new InvalidOperationException();
})
.Test()
.AssertFailure(typeof(InvalidOperationException), 1, 2, 3, 4, 5);
Assert.True(sad.IsDisposed());
}
public void Basic_Serialized()
{
var sad = new SingleAssignmentDisposable();
ReactiveExtensions.Create <int>(emitter =>
{
emitter.SetResource(sad);
for (int i = 1; i < 6; i++)
{
emitter.OnNext(i);
}
emitter.OnCompleted();
}, true)
.Test()
.AssertResult(1, 2, 3, 4, 5);
Assert.True(sad.IsDisposed());
}
public void OnNext_Race()
{
for (int i = 0; i < TestHelper.RACE_LOOPS; i++)
{
var to = new TestObserver <int>();
var s = ReactiveExtensions.ToSerialized(to);
Action emit = () => {
for (int j = 0; j < 500; j++)
{
s.OnNext(j);
}
};
TestHelper.Race(emit, emit);
to.AssertValueCount(1000);
}
}
public void Basic_Single_Step()
{
var ts = new TestScheduler();
var to = ReactiveExtensions
.IntervalRange(0, 5, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2), ts)
.Test();
to.AssertEmpty();
ts.AdvanceTimeBy(500);
to.AssertEmpty();
ts.AdvanceTimeBy(TimeSpan.FromMilliseconds(500));
to.AssertValuesOnly(0);
ts.AdvanceTimeBy(TimeSpan.FromMilliseconds(1000));
to.AssertValuesOnly(0);
ts.AdvanceTimeBy(TimeSpan.FromMilliseconds(2000));
to.AssertValuesOnly(0, 1);
ts.AdvanceTimeBy(2000);
to.AssertValuesOnly(0, 1, 2);
ts.AdvanceTimeBy(TimeSpan.FromMilliseconds(2000));
to.AssertValuesOnly(0, 1, 2, 3);
ts.AdvanceTimeBy(TimeSpan.FromMilliseconds(2000));
to.AssertResult(0, 1, 2, 3, 4);
Assert.False(ts.HasTasks());
}
public void Error()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
var to = ReactiveExtensions.CombineLatest(a =>
{
int v = 0;
foreach (var e in a)
{
v += e;
}
return(v);
}, us1, us2).Test();
to.AssertEmpty();
us1.OnError(new InvalidOperationException());
Assert.False(us2.HasObserver());
to.AssertFailure(typeof(InvalidOperationException));
}
public void Error_Second_Source()
{
var us1 = new UnicastSubject <int>();
var us2 = new UnicastSubject <int>();
var to = ReactiveExtensions.Zip(a =>
{
int s = 0;
foreach (var v in a)
{
s += v;
}
return(s);
},
us1,
us2
).Test();
us1.OnNext(1);
to.AssertEmpty();
us1.OnNext(2);
to.AssertEmpty();
us2.OnNext(10);
to.AssertValuesOnly(11);
us2.OnError(new InvalidOperationException());
Assert.False(us1.HasObserver());
to.AssertFailure(typeof(InvalidOperationException), 11);
}
public static IObservable <SearchedFile> FindReferences(IEntity entity, IProgressMonitor progressMonitor)
{
return(ReactiveExtensions.CreateObservable <SearchedFile>(
(monitor, callback) => FindReferencesAsync(entity, monitor, callback),
progressMonitor));
}
public static IObservable <Error> RenameSymbol(ISymbol symbol, string newName, IProgressMonitor progressMonitor)
{
return(ReactiveExtensions.CreateObservable <Error>(
(monitor, callback) => RenameSymbolAsync(symbol, newName, monitor, callback),
progressMonitor));
}
public static IObservable <SearchedFile> FindLocalReferences(IVariable variable, IProgressMonitor progressMonitor)
{
return(ReactiveExtensions.CreateObservable <SearchedFile>(
(monitor, callback) => FindLocalReferencesAsync(variable, monitor).ContinueWith(t => callback(t.Result)),
progressMonitor));
}