public static void EmbargoOnPromisedAnswer(ITestbed testbed)
{
var counters = new Counters();
var impl = new TestMoreStuffImpl(counters);
using (var main = testbed.ConnectMain <ITestMoreStuff>(impl))
{
if (main is IResolvingCapability resolving)
{
testbed.MustComplete(resolving.WhenResolved.WrappedTask);
}
var cap = new TestCallOrderImpl();
cap.CountToDispose = 6;
var earlyCall = main.GetCallSequence(0, default);
var echo = main.Echo(cap, default);
testbed.MustComplete(Task.CompletedTask);
using (var pipeline = echo.Eager(true))
{
var call0 = pipeline.GetCallSequence(0, default);
var call1 = pipeline.GetCallSequence(1, default);
testbed.MustComplete(earlyCall);
impl.EnableEcho();
var call2 = pipeline.GetCallSequence(2, default);
testbed.MustComplete(echo);
using (var resolved = echo.Result)
{
var call3 = pipeline.GetCallSequence(3, default);
var call4 = pipeline.GetCallSequence(4, default);
var call5 = pipeline.GetCallSequence(5, default);
testbed.MustComplete(call0);
testbed.MustComplete(call1);
testbed.MustComplete(call2);
testbed.MustComplete(call3);
testbed.MustComplete(call4);
testbed.MustComplete(call5);
Assert.AreEqual(0u, call0.Result);
Assert.AreEqual(1u, call1.Result);
Assert.AreEqual(2u, call2.Result);
Assert.AreEqual(3u, call3.Result);
Assert.AreEqual(4u, call4.Result);
Assert.AreEqual(5u, call5.Result);
Assert.AreEqual(cap.Count, cap.CountToDispose, "counter must have reached number of calls");
}
}
}
}
public void EagerRace()
{
var impl = new TestMoreStuffImpl(new Counters());
var tcs = new TaskCompletionSource <ITestMoreStuff>();
using (var promise = tcs.Task.Eager(true))
using (var cts = new CancellationTokenSource())
{
var bb = new BufferBlock <Task <uint> >();
int counter = 0;
void Generator()
{
while (!cts.IsCancellationRequested)
{
bb.Post(promise.GetCallSequence((uint)Volatile.Read(ref counter)));
Interlocked.Increment(ref counter);
}
bb.Complete();
}
async Task Verifier()
{
uint i = 0;
while (true)
{
Task <uint> t;
try
{
t = await bb.ReceiveAsync();
}
catch (InvalidOperationException)
{
break;
}
uint j = await t;
Assert.AreEqual(i, j);
i++;
}
}
var genTask = Task.Run(() => Generator());
var verTask = Verifier();
SpinWait.SpinUntil(() => Volatile.Read(ref counter) >= 100);
Task.Run(() => tcs.SetResult(impl));
cts.Cancel();
Assert.IsTrue(genTask.Wait(MediumNonDbgTimeout));
Assert.IsTrue(verTask.Wait(MediumNonDbgTimeout));
}
}
public static void EmbargoNull(ITestbed testbed)
{
var counters = new Counters();
var impl = new TestMoreStuffImpl(counters);
using (var main = testbed.ConnectMain <ITestMoreStuff>(impl))
{
if (main is IResolvingCapability resolving)
{
testbed.MustComplete(resolving.WhenResolved.WrappedTask);
}
var promise = main.GetNull(default);
public static void EmbargoError(ITestbed testbed)
{
var counters = new Counters();
var impl = new TestMoreStuffImpl(counters);
using (var main = testbed.ConnectMain <ITestMoreStuff>(impl))
{
if (main is IResolvingCapability resolving)
{
testbed.MustComplete(resolving.WhenResolved.WrappedTask);
}
var cap = new TaskCompletionSource <ITestCallOrder>();
var earlyCall = main.GetCallSequence(0, default);
var echo = main.Echo(cap.Task.Eager(true), default);
using (var pipeline = echo.Eager(true))
{
var call0 = pipeline.GetCallSequence(0, default);
var call1 = pipeline.GetCallSequence(1, default);
testbed.MustComplete(earlyCall);
impl.EnableEcho();
var call2 = pipeline.GetCallSequence(2, default);
testbed.MustComplete(echo);
var resolved = echo.Result;
var call3 = pipeline.GetCallSequence(3, default);
var call4 = pipeline.GetCallSequence(4, default);
var call5 = pipeline.GetCallSequence(5, default);
cap.SetException(new InvalidTimeZoneException("I'm annoying"));
testbed.ExpectPromiseThrows(call0, call1, call2, call3, call4, call5);
// Verify that we're still connected (there were no protocol errors).
testbed.MustComplete(main.GetCallSequence(1, default));
}
}
}
public void ResolveMain()
{
Repeat(5000, () =>
{
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
//client.WhenConnected.Wait();
var counters = new Counters();
var impl = new TestMoreStuffImpl(counters);
server.Main = impl;
using (var main = client.GetMain <ITestMoreStuff>())
{
var resolving = main as IResolvingCapability;
Assert.IsTrue(resolving.WhenResolved.WrappedTask.Wait(MediumNonDbgTimeout));
}
}
});
}
public void InterceptClientSideModifyPipelinedCall()
{
var policy = new MyPolicy("a");
(var server, var client) = SetupClientServerPair(TcpRpcTestOptions.ClientTracer);
using (server)
using (client)
{
var counters = new Counters();
var impl = new TestMoreStuffImpl(counters);
server.Main = impl;
using (var main = policy.Attach(client.GetMain <ITestMoreStuff>()))
{
var req = main.GetNull().Eager().GetCallSequence(0);
Assert.IsTrue(policy.Calls.TryReceive(out var ccGetNull));
Assert.IsTrue(policy.Calls.TryReceive(out var ccGetCallSequence));
ccGetNull.ForwardToBob();
Assert.IsTrue(policy.Returns.ReceiveAsync().Wait(MediumNonDbgTimeout));
ccGetNull.ReturnToAlice();
ccGetCallSequence.Bob = Proxy.Share <ITestMoreStuff>(impl);
ccGetCallSequence.ForwardToBob();
Assert.IsTrue(policy.Returns.ReceiveAsync().Wait(MediumNonDbgTimeout));
ccGetCallSequence.ReturnToAlice();
Assert.IsTrue(req.IsCompleted && !req.IsFaulted && !req.IsCanceled);
Assert.AreEqual(0u, req.Result);
}
}
}
