public void SkipUntil_ArgumentChecking()
{
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.SkipUntil <int, int>(null, DummySubscribable <int> .Instance));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.SkipUntil <int, int>(DummySubscribable <int> .Instance, null));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.SkipUntil(default(ISubscribable <int>), DateTimeOffset.Now));
}
public void Throttle_ArgumentChecking()
{
var someObservable = Subscribable.Empty <int>();
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Throttle(default(ISubscribable <int>), TimeSpan.Zero));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => Subscribable.Throttle(someObservable, TimeSpan.FromSeconds(-1)));
}
public PencilGamingWindows(int width, int height, string title, bool isFullscreen, bool shouldVsync)
{
onWindowOpened = new Trigger<PencilGamingWindows>();
OnWindowOpened = onWindowOpened;
onWindowClosed = new Trigger<PencilGamingWindows>();
OnWindowClosed = onWindowClosed;
onWindowResized = new Trigger<PencilGamingWindows>();
OnWindowResized = onWindowResized;
onKeyboard = new Trigger<PencilKeyInfo>();
OnKeyboard = onKeyboard;
onExit = new Trigger<PencilGamingWindows>();
OnExit = onExit;
window = GlfwWindowPtr.Null;
this.width = width;
this.height = height;
this.title = title;
this.isFullscreen = isFullscreen;
this.shouldVsync = shouldVsync;
this.firstTime = true;
if (!Glfw.Init())
{
Console.Error.WriteLine("ERROR: Could not initialize GLFW, shutting down.");
Environment.Exit(1);
}
}
public PencilGamingWindows(int width, int height, string title, bool isFullscreen, bool shouldVsync)
{
onWindowOpened = new Trigger <PencilGamingWindows>();
OnWindowOpened = onWindowOpened;
onWindowClosed = new Trigger <PencilGamingWindows>();
OnWindowClosed = onWindowClosed;
onWindowResized = new Trigger <PencilGamingWindows>();
OnWindowResized = onWindowResized;
onKeyboard = new Trigger <PencilKeyInfo>();
OnKeyboard = onKeyboard;
onExit = new Trigger <PencilGamingWindows>();
OnExit = onExit;
window = GlfwWindowPtr.Null;
this.width = width;
this.height = height;
this.title = title;
this.isFullscreen = isFullscreen;
this.shouldVsync = shouldVsync;
this.firstTime = true;
if (!Glfw.Init())
{
Console.Error.WriteLine("ERROR: Could not initialize GLFW, shutting down.");
Environment.Exit(1);
}
}
public void All_ArgumentChecking()
{
#pragma warning disable IDE0034 // Simplify 'default' expression (illustrative of method signature)
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.All <int>(default(ISubscribable <int>), x => true));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.All <int>(DummySubscribable <int> .Instance, default(Func <int, bool>)));
#pragma warning restore IDE0034 // Simplify 'default' expression
}
public void Contains_ArgumentChecking()
{
#pragma warning disable IDE0034 // Simplify 'default' expression (illustrative of method signature)
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Contains <int>(default(ISubscribable <int>), 0));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Contains <int>(DummySubscribable <int> .Instance, 0, null));
#pragma warning restore IDE0034 // Simplify 'default' expression
}
public void SelectMany_QueryOperator_ThrowResult()
{
Run(client =>
{
var xs = client.CreateHotObservable(
OnNext(220, 4),
OnNext(221, 3),
OnNext(222, 2),
OnNext(223, 5),
OnCompleted <int>(224)
);
var ex = new Exception();
var res = client.Start(() =>
from x in xs
from y in Subscribable.Timer(TimeSpan.FromTicks(1), TimeSpan.FromTicks(1)).Take(x)
select Throw <int>(ex)
);
res.Messages.AssertEqual(
OnError <int>(221, ex)
);
xs.Subscriptions.AssertEqual(
Subscribe(200, 221)
);
});
}
public void Do_ArgumentChecking()
{
#pragma warning disable IDE0034 // Simplify 'default' expression (illustrative of method signature)
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int>(default(ISubscribable <int>), DummyObserver <int> .Instance));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int>(DummySubscribable <int> .Instance, default(IObserver <int>)));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int>(default(ISubscribable <int>), _ => { }));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int>(DummySubscribable <int> .Instance, default(Action <int>)));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int>(default(ISubscribable <int>), _ => { }, () => { }));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int>(DummySubscribable <int> .Instance, default(Action <int>), () => { }));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int>(DummySubscribable <int> .Instance, _ => { }, default(Action)));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int>(default(ISubscribable <int>), _ => { }, _ => { }));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int>(DummySubscribable <int> .Instance, default(Action <int>), _ => { }));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int>(DummySubscribable <int> .Instance, _ => { }, default(Action <Exception>)));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int>(default(ISubscribable <int>), _ => { }, _ => { }, () => { }));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int>(DummySubscribable <int> .Instance, default(Action <int>), _ => { }, () => { }));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int>(DummySubscribable <int> .Instance, _ => { }, default(Action <Exception>), () => { }));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int>(DummySubscribable <int> .Instance, _ => { }, _ => { }, default(Action)));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int, int>(default(ISubscribable <int>), x => x, DummyObserver <int> .Instance));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int, int>(DummySubscribable <int> .Instance, default(Func <int, int>), DummyObserver <int> .Instance));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Do <int, int>(DummySubscribable <int> .Instance, x => x, default(IObserver <int>)));
#pragma warning restore IDE0034 // Simplify 'default' expression
}
public void Quoter_WithEnvironment()
{
var quoter = new Quoter(DefaultExpressionPolicy.Instance);
var expr = (Expression <Func <int, ISubscribable <int> > >)(x => Subscribable.Return(x));
var res = quoter.Visit(expr);
var obj = (Func <int, ISubscribable <int> >)res.Evaluate();
var value = obj(42);
var quote = ((IExpressible)value).Expression;
var eq = new ExpressionEqualityComparer();
Assert.IsTrue(
eq.Equals(
Expression.Invoke(
expr,
Expression.Constant(42)
),
quote
)
);
}
public void Serializer_Qubscribable_WithPolicy()
{
var input = new QuotedSubscribable <int>(Subscribable.Empty <int>(), ((Expression <Func <ISubscribable <int> > >)(() => Subscribable.Empty <int>())).Body);
var policy = new TestPolicy();
Assert.AreEqual(0, policy.ConstantHoisterCalls);
Assert.AreEqual(0, policy.DelegateCacheCalls);
Assert.AreEqual(0, policy.InMemoryCacheCalls);
Assert.AreEqual(0, policy.OutlineCompilationCalls);
Assert.AreEqual(0, policy.ReflectionProviderCalls);
Assert.AreEqual(0, policy.ExpressionFactoryCalls);
var quotedResult = Roundtrip(input, new Serializer(policy, SerializerVersioning.v1));
Assert.AreEqual(1, policy.ConstantHoisterCalls);
Assert.AreEqual(1, policy.DelegateCacheCalls);
Assert.AreEqual(1, policy.InMemoryCacheCalls);
Assert.AreEqual(1, policy.OutlineCompilationCalls);
Assert.AreEqual(1, policy.ReflectionProviderCalls);
Assert.AreEqual(1, policy.ExpressionFactoryCalls);
Assert.IsNotNull(quotedResult);
Assert.AreEqual(input.Value.GetType(), quotedResult.Value.GetType());
}
public void Buffer_ArgumentChecking()
{
var ns = default(ISubscribable <int>);
var xs = DummySubscribable <int> .Instance;
var n = 1;
var t = TimeSpan.FromSeconds(1);
var u = -t;
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Buffer(ns, n));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Buffer(ns, n, n));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Buffer(ns, t, n));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => Subscribable.Buffer(xs, 0));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => Subscribable.Buffer(xs, 0, n));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => Subscribable.Buffer(xs, n, 0));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => Subscribable.Buffer(xs, t, 0));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Buffer(ns, t));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Buffer(ns, t, t));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => Subscribable.Buffer(xs, u));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => Subscribable.Buffer(xs, u, t));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => Subscribable.Buffer(xs, t, u));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => Subscribable.Buffer(xs, u, n));
}
public void GroupBy_ArgumentChecking()
{
var ns = default(ISubscribable <int>);
var xs = DummySubscribable <int> .Instance;
var nk = default(Func <int, int>);
var dk = new Func <int, int>(x => x);
var nc = default(IEqualityComparer <int>);
var dc = EqualityComparer <int> .Default;
var ne = default(Func <int, string>);
var de = new Func <int, string>(x => x.ToString());
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.GroupBy(ns, dk));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.GroupBy(xs, nk));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.GroupBy(ns, dk, dc));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.GroupBy(xs, nk, dc));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.GroupBy(xs, dk, nc));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.GroupBy(ns, dk, de));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.GroupBy(xs, nk, de));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.GroupBy(xs, dk, ne));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.GroupBy(ns, dk, de, dc));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.GroupBy(xs, nk, de, dc));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.GroupBy(xs, dk, ne, dc));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.GroupBy(xs, dk, de, nc));
}
public void RepeatingTimer_Overflow2()
{
ISubscription sub = null;
IOperatorContext context = Scheduler.CreateContext();
var state = Scheduler.CreateStateContainer();
var checkpoints = new[]
{
OnSave(152, state)
};
// Create new subscription allow the timer to fire twice.
var res1 = Scheduler.CreateObserver <long>();
Scheduler.ScheduleAbsolute(100, () => { sub = Subscribable.Timer(TimeSpan.MinValue).Apply(Scheduler, checkpoints).Subscribe(res1, context); });
Scheduler.ScheduleAbsolute(155, () => sub.Dispose());
// Create new subscription and load the state.
var res2 = Scheduler.CreateObserver <long>();
Scheduler.ScheduleAbsolute(200, () => sub = Subscribable.Timer(TimeSpan.MinValue).Subscribe(res2, context, state));
Scheduler.ScheduleAbsolute(255, () => sub.Dispose());
Scheduler.Start();
res1.Messages.AssertEqual(
new[]
{
OnNext(100, 0L),
OnCompleted(100, 0L),
});
res2.Messages.AssertEqual(Array.Empty <Recorded <Notification <long> > >());
}
public void RepeatingTimer_RestoreOlderCheckpoint()
{
var oldState = Scheduler.CreateStateContainer();
var newState = Scheduler.CreateStateContainer();
var checkpoints = new[]
{
OnSave(255, oldState),
OnSave(305, newState),
OnSave(405, newState),
OnLoad(406, oldState)
};
var result = Scheduler.Start(
() => Subscribable.Timer(TimeSpan.Zero, TimeSpan.FromTicks(50)).Apply(Scheduler, checkpoints),
disposed: 460);
result.Messages.AssertEqual(new[]
{
OnNext(Subscribed, 0L),
OnNext(250, 1L),
// Saved old state here
OnNext(300, 2L),
OnNext(350, 3L),
OnNext(400, 4L),
// Loaded old state here
OnNext(450, 2L),
OnNext(450, 3L),
OnNext(450, 4L),
OnNext(450, 5L)
});
}
public void Throttle_Duration_ArgumentChecking()
{
var someObservable = DummySubscribable <int> .Instance;
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Throttle(default(ISubscribable <int>), x => someObservable));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Throttle(someObservable, default(Func <int, ISubscribable <string> >)));
}
public void Retry_Observable_RetryCount_Default_ArgumentChecking()
{
#pragma warning disable IDE0034 // Simplify 'default' expression (illustrative of method signature)
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Retry <int>(default(ISubscribable <int>), 0));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => DummySubscribable <int> .Instance.Retry(-1));
ReactiveAssert.Throws <ArgumentNullException>(() => DummySubscribable <int> .Instance.Retry(0).Subscribe(null));
#pragma warning restore IDE0034 // Simplify 'default' expression
}
public void OneShotTimer_TimeSpan_OnCompletedObserverThrows()
{
var xs = Subscribable.Timer(TimeSpan.FromTicks(1));
var observer = new OnCompletedThrowsObserver <long>();
var sub = xs.Subscribe(observer, Scheduler.CreateContext());
ReactiveAssert.Throws <InvalidOperationException>(() => Scheduler.Start());
}
public void DelaySubscription_ArgumentChecking()
{
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.DelaySubscription(default(ISubscribable <int>), DateTimeOffset.Now));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.DelaySubscription(default(ISubscribable <int>), TimeSpan.Zero));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => Subscribable.DelaySubscription(DummySubscribable <int> .Instance, TimeSpan.FromSeconds(-1)));
}
public void MinComparer_ArgumentChecking()
{
#pragma warning disable IDE0034 // Simplify 'default' expression (illustrative of method signature)
Assert.ThrowsException <ArgumentNullException>(() => Subscribable.Min <string>(default(ISubscribable <string>)));
Assert.ThrowsException <ArgumentNullException>(() => Subscribable.Min <string>(default(ISubscribable <string>), StringComparer.Ordinal));
Assert.ThrowsException <ArgumentNullException>(() => Subscribable.Min <string>(DummySubscribable <string> .Instance, default(IComparer <string>)));
#pragma warning restore IDE0034 // Simplify 'default' expression
}
public void Serializer_QubscribableRoundtrips()
{
var input = new QuotedSubscribable <int>(Subscribable.Empty <int>(), ((Expression <Func <ISubscribable <int> > >)(() => Subscribable.Empty <int>())).Body);
var quotedResult = Roundtrip(input, new Serializer(DefaultExpressionPolicy.Instance, SerializerVersioning.v1));
Assert.IsNotNull(quotedResult);
Assert.AreEqual(input.Value.GetType(), quotedResult.Value.GetType());
}
public void Take_ArgumentChecking()
{
ReactiveAssert.Throws <ArgumentNullException>(() => ((ISubscribable <int>)null).Take(0));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => DummySubscribable <int> .Instance.Take(-1));
ReactiveAssert.Throws <ArgumentNullException>(() => DummySubscribable <int> .Instance.Take(1).Subscribe(null));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Take(default(ISubscribable <int>), TimeSpan.FromSeconds(1)));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => Subscribable.Take(DummySubscribable <int> .Instance, TimeSpan.FromSeconds(-1)));
}
public void Sample_ArgumentChecking()
{
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Sample(default(ISubscribable <int>), TimeSpan.Zero));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => Subscribable.Sample(DummySubscribable <int> .Instance, TimeSpan.FromSeconds(-1)));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Sample(default(ISubscribable <int>), DummySubscribable <int> .Instance));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Sample(DummySubscribable <int> .Instance, default(ISubscribable <int>)));
}
public void Scan_ArgumentChecking()
{
#pragma warning disable IDE0034 // Simplify 'default' expression (illustrative of method signature)
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Scan <int>(default(ISubscribable <int>), (l, r) => l + r));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Scan <int>(DummySubscribable <int> .Instance, default(Func <int, int, int>)));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Scan <int, int>(default(ISubscribable <int>), 0, (l, r) => l + r));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Scan <int, int>(DummySubscribable <int> .Instance, 0, default(Func <int, int, int>)));
var nullSeedAllowed = Subscribable.Scan <int, string>(DummySubscribable <int> .Instance, default(string), (s, x) => s + x);
#pragma warning restore IDE0034 // Simplify 'default' expression
}
public void Finally_OnlyCalledOnce_Empty()
{
var invokeCount = 0;
var someObservable = Subscribable.Empty <int>().Finally(() => { invokeCount++; });
var d = someObservable.Subscribe();
d.Dispose();
d.Dispose();
Assert.AreEqual(1, invokeCount);
}
public void Distinct_ArgumentChecking()
{
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Distinct <int>(null));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Distinct <int>(null, EqualityComparer <int> .Default));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Distinct <int>(DummySubscribable <int> .Instance, null));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Distinct <int, int>(null, _ => _));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Distinct <int, int>(DummySubscribable <int> .Instance, null));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Distinct <int, int>(DummySubscribable <int> .Instance, _ => _, null));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Distinct <int, int>(null, _ => _, EqualityComparer <int> .Default));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.Distinct <int, int>(DummySubscribable <int> .Instance, null, EqualityComparer <int> .Default));
}
public void SelectMany_ArgumentChecking()
{
var ns = default(ISubscribable <int>);
var xs = DummySubscribable <int> .Instance;
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.SelectMany(ns, _ => xs));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.SelectMany(xs, default(Func <int, ISubscribable <string> >)));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.SelectMany(ns, _ => xs, (x, y) => x + y));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.SelectMany(xs, default(Func <int, ISubscribable <string> >), (x, y) => x + y));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.SelectMany(xs, _ => xs, default(Func <int, int, int>)));
}
public void Retry_Observable_Throws3()
{
Run(scheduler =>
{
var zs = Subscribable.Return(1).Apply(scheduler).Retry();
var sub = zs.Subscribe(Observer.Create <int>(x => { }, ex => { }, () => { throw new InvalidOperationException(); }));
InitializeSubscription(sub, scheduler);
ReactiveAssert.Throws <InvalidOperationException>(() => scheduler.Start());
});
}
public void SequenceEqual_ArgumentChecking()
{
var ns = default(ISubscribable <int>);
var xs = DummySubscribable <int> .Instance;
var nc = default(IEqualityComparer <int>);
var ic = EqualityComparer <int> .Default;
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.SequenceEqual(ns, xs));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.SequenceEqual(xs, ns));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.SequenceEqual(ns, xs, ic));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.SequenceEqual(xs, ns, ic));
ReactiveAssert.Throws <ArgumentNullException>(() => Subscribable.SequenceEqual(xs, xs, nc));
}
public void Quoter_NoEnviroment()
{
var quoter = new Quoter(DefaultExpressionPolicy.Instance);
var expr = Expression.Constant(Subscribable.Return(42), typeof(ISubscribable <int>));
var res = quoter.Visit(expr);
var obj = res.Evaluate();
var quote = ((IExpressible)obj).Expression;
Assert.AreSame(expr, quote);
}
public void Retry_Observable_Throws2()
{
Run(scheduler =>
{
var ys = Subscribable.Throw <int>(new Exception()).Apply(scheduler).Retry();
var sub = ys.Subscribe(Observer.Create <int>(x => { }, ex => { throw new InvalidOperationException(); }, () => { }));
InitializeSubscription(sub, scheduler);
scheduler.ScheduleAbsolute(210, () => sub.Dispose());
scheduler.Start();
});
}
public void ReliableMultiSubjectProxy_AsObserver_InvalidEnvironment()
{
Run(client =>
{
var env = new TestExecutionEnvironment();
var ctx = client.CreateContext(env);
var uri = new Uri("test://subject");
var observer = new SubscriptionObserver <int>();
var subject = new TestSubject <int>(observer);
env.AddArtifact(uri, subject);
var proxy = new ReliableMultiSubjectProxy <int, int>(uri);
var sub = SubscribeRoot(Subscribable.Never <int>(), new ObserverToReliableObserver <int>(proxy.CreateObserver()));
Assert.ThrowsException <InvalidOperationException>(() => new SubscriptionInitializeVisitor(sub).Initialize(ctx));
});
}
