public void DetachWrongUse()
{
var impl = new TestInterfaceImpl2();
Assert.ThrowsException <ArgumentNullException>(() => default(IInterceptionPolicy).Detach(impl));
Assert.ThrowsException <ArgumentNullException>(() => new MyPolicy("x").Detach(default(ITestInterface)));
}
public void DisposedProxy()
{
var b = new BareProxy();
Assert.ThrowsException <ArgumentNullException>(() => b.Bind(null));
var impl = new TestInterfaceImpl2();
var proxy = Proxy.Share <ITestInterface>(impl);
var p = (Proxy)proxy;
Assert.ThrowsException <InvalidOperationException>(() => p.Bind(p.ConsumedCap));
Assert.IsFalse(p.IsDisposed);
proxy.Dispose();
Assert.IsTrue(p.IsDisposed);
Assert.ThrowsException <ObjectDisposedException>(() => p.ConsumedCap);
var t = proxy.Foo(123, true);
Assert.IsTrue(Assert.ThrowsExceptionAsync <ObjectDisposedException>(() => t).Wait(MediumNonDbgTimeout));
}
public async Task Unwrap()
{
var impl = new TestInterfaceImpl2();
Assert.AreEqual(impl, await impl.Unwrap <ITestInterface>());
using (var proxy = Proxy.Share <ITestInterface>(impl))
using (var reso = ((Proxy)proxy).GetResolvedCapability <ITestInterface>())
{
Assert.AreEqual(((Proxy)proxy).ConsumedCap, ((Proxy)reso).ConsumedCap);
}
Assert.IsNull(await default(ITestInterface).Unwrap());
var tcs = new TaskCompletionSource <ITestInterface>();
tcs.SetResult(null);
Assert.IsNull(await tcs.Task.Eager(true).Unwrap());
var excepted = Task.FromException <ITestInterface>(new InvalidTimeZoneException("So annoying"));
await Assert.ThrowsExceptionAsync <RpcException>(async() => await excepted.Eager(true).Unwrap());
}
public void ReadCapList()
{
var mb = MessageBuilder.Create();
mb.InitCapTable();
var dss = mb.CreateObject <DynamicSerializerState>();
dss.SetStruct(0, 1);
var loc = mb.CreateObject <ListOfCapsSerializer <ITestInterface> >();
loc.Init(1);
loc[0] = new TestInterfaceImpl2();
dss.LinkObject(0, loc);
var d = (DeserializerState)dss;
var cl = d.ReadCapList <ITestInterface>(0);
Assert.AreEqual(1, cl.Count);
Assert.IsNotNull(cl[0]);
}
public void InterceptServerSideRedirectCall()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
var counters = new Counters();
server.Main = policy.Attach <ITestInterface>(new TestInterfaceImpl(counters));
var redirTarget = new TestInterfaceImpl2();
using (var main = client.GetMain <ITestInterface>())
using (redirTarget)
{
var request1 = main.Foo(123, true, default);
var fcc = policy.Calls.ReceiveAsync();
Assert.IsTrue(fcc.Wait(MediumNonDbgTimeout));
var cc = fcc.Result;
Assert.ThrowsException <ArgumentNullException>(() => cc.Bob = null);
cc.Bob = redirTarget;
cc.ForwardToBob();
Assert.IsTrue(policy.Returns.ReceiveAsync().Wait(MediumNonDbgTimeout));
cc.ReturnToAlice();
Assert.IsTrue(request1.Wait(MediumNonDbgTimeout));
Assert.AreEqual("bar", request1.Result);
}
Assert.IsTrue(redirTarget.IsDisposed);
Assert.AreEqual(0, counters.CallCount);
}
}
