internal override IPromisedAnswer DoCall(ulong interfaceId, ushort methodId, DynamicSerializerState args)
{
var cts = new CancellationTokenSource();
var call = ProvidedCap.Invoke(interfaceId, methodId, args, cts.Token);
return(new LocalAnswer(cts, AwaitAnswer(call)));
}
async Task <DeserializerState> CallImpl(ulong interfaceId, ushort methodId, DynamicSerializerState args, CancellationToken cancellationToken)
{
ConsumedCapability cap;
try
{
cap = await _capTask;
}
catch
{
args.Dispose();
throw;
}
if (cancellationToken.IsCancellationRequested)
{
args.Dispose();
cancellationToken.ThrowIfCancellationRequested();
}
using var proxy = new Proxy(cap);
var call = proxy.Call(interfaceId, methodId, args, default);
var whenReturned = call.WhenReturned;
using (var registration = cancellationToken.Register(call.Dispose))
{
return(await whenReturned);
}
}
public void CallServerSideException()
{
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout));
SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumNonDbgTimeout);
Assert.AreEqual(1, server.ConnectionCount);
var mock = new ProvidedCapabilityMock();
server.Main = mock;
var main = client.GetMain <BareProxy>();
Assert.IsTrue(main.WhenResolved.WrappedTask.Wait(MediumNonDbgTimeout));
var args = DynamicSerializerState.CreateForRpc();
args.SetStruct(1, 0);
args.WriteData(0, 123456);
using (var answer = main.Call(0x1234567812345678, 0x3333, args))
{
Assert.IsTrue(mock.WhenCalled.Wait(MediumNonDbgTimeout));
(var interfaceId, var methodId, var inargs, var ct) = mock.WhenCalled.Result;
Assert.AreEqual <ulong>(0x1234567812345678, interfaceId);
Assert.AreEqual <ushort>(0x3333, methodId);
Assert.AreEqual(ObjectKind.Struct, inargs.Kind);
Assert.AreEqual(123456, inargs.ReadDataInt(0));
mock.Return.SetException(new MyTestException());
var exTask = Assert.ThrowsExceptionAsync <RpcException>(async() => await answer.WhenReturned);
Assert.IsTrue(exTask.Wait(MediumNonDbgTimeout));
Assert.IsTrue(exTask.Result.Message.Contains(new MyTestException().Message));
}
}
}
internal override IPromisedAnswer DoCall(ulong interfaceId, ushort methodId, DynamicSerializerState args)
{
var cc = new CallContext(this, interfaceId, methodId, args);
Policy.OnCallFromAlice(cc);
return(cc.Answer);
}
internal override IPromisedAnswer DoCall(ulong interfaceId, ushort methodId, DynamicSerializerState args)
{
var call = SetupMessage(args, interfaceId, methodId);
Debug.Assert(call.Target.which != MessageTarget.WHICH.undefined);
return(_ep.BeginQuestion(this, args));
}
public void StructWithLists()
{
var mb = MessageBuilder.Create(8);
var alloc = mb.Allocator;
var ds = new DynamicSerializerState(mb);
{
ds.SetStruct(0, 2);
ds.WriteText(0, "Lorem ipsum");
var los = ds.BuildPointer(1);
los.SetListOfStructs(3, 1, 1);
var e0 = los.ListBuildStruct(0);
e0.WriteData(0, long.MinValue);
e0.WriteText(0, long.MinValue.ToString());
var e1 = los.ListBuildStruct(1);
e1.WriteData(0, 0L);
e1.WriteText(0, 0L.ToString());
var e2 = los.ListBuildStruct(2);
e2.WriteData(0, long.MaxValue);
e2.WriteText(0, long.MaxValue.ToString());
}
{
DeserializerState d = ds;
Assert.AreEqual(ObjectKind.Struct, d.Kind);
Assert.AreEqual("Lorem ipsum", d.ReadText(0));
var los = d.ReadListOfStructs(1, _ => _);
Assert.AreEqual(3, los.Count);
Assert.AreEqual(long.MinValue, los[0].ReadDataLong(0));
Assert.AreEqual(long.MinValue.ToString(), los[0].ReadText(0));
Assert.AreEqual(0L, los[1].ReadDataLong(0));
Assert.AreEqual(0L.ToString(), los[1].ReadText(0));
Assert.AreEqual(long.MaxValue, los[2].ReadDataLong(0));
Assert.AreEqual(long.MaxValue.ToString(), los[2].ReadText(0));
}
}
public void ListOfBytesAsListOfStructs()
{
var ds = new DynamicSerializerState(MessageBuilder.Create(128));
ds.SetListOfValues(8, 10);
ds.ListWriteValue(1, (byte)0x11);
ds.ListWriteValue(2, (byte)0x22);
ds.ListWriteValue(3, (byte)0x33);
ds.ListWriteValue(4, (byte)0x44);
ds.ListWriteValue(5, (byte)0x55);
ds.ListWriteValue(6, (byte)0x66);
ds.ListWriteValue(7, (byte)0x77);
ds.ListWriteValue(8, (byte)0x88);
ds.ListWriteValue(9, (byte)0x99);
DeserializerState d = ds;
var asListOfStructs = d.RequireList().Cast(_ => _);
Assert.AreEqual(10, asListOfStructs.Count);
Assert.AreEqual(ObjectKind.Value, asListOfStructs[0].Kind);
Assert.AreEqual((byte)0x00, asListOfStructs[0].ReadDataByte(0));
Assert.AreEqual((byte)0x11, asListOfStructs[1].ReadDataByte(0));
Assert.AreEqual((byte)0x22, asListOfStructs[2].ReadDataByte(0));
Assert.AreEqual((byte)0x33, asListOfStructs[3].ReadDataByte(0));
Assert.AreEqual((byte)0x44, asListOfStructs[4].ReadDataByte(0));
Assert.AreEqual((byte)0x55, asListOfStructs[5].ReadDataByte(0));
Assert.AreEqual((byte)0x66, asListOfStructs[6].ReadDataByte(0));
Assert.AreEqual((byte)0x77, asListOfStructs[7].ReadDataByte(0));
Assert.AreEqual((byte)0x88, asListOfStructs[8].ReadDataByte(0));
Assert.AreEqual((byte)0x99, asListOfStructs[9].ReadDataByte(0));
}
public void List2D()
{
var mb = MessageBuilder.Create(128);
var alloc = mb.Allocator;
var ds = new DynamicSerializerState(mb);
int w = 4;
int h = 5;
ds.SetListOfPointers(w);
for (int i = 0; i < w; i++)
{
var p = ds.BuildPointer(i);
p.SetListOfValues(32, h);
for (int j = 0; j < h; j++)
{
p.ListWriteValue(j, i - j);
}
}
DeserializerState d = ds;
var matrix = d.RequireList().Cast2D <int>();
Assert.AreEqual(matrix.Count, w);
for (int i = 0; i < w; i++)
{
var v = matrix[i];
Assert.AreEqual(h, v.Count);
for (int j = 0; j < h; j++)
{
Assert.AreEqual(i - j, v[j]);
}
}
}
public void ListOfULongs()
{
var mb = MessageBuilder.Create(1);
var alloc = mb.Allocator;
var ds = new DynamicSerializerState(mb);
int count = 345;
ds.SetListOfValues(64, count);
for (int i = 0; i < count; i++)
{
ds.ListWriteValue(i, (ulong)i);
}
DeserializerState d = ds;
Assert.AreEqual(count, d.ListElementCount);
var ulongs = d.RequireList().CastULong();
for (int i = 0; i < count; i++)
{
Assert.AreEqual((ulong)i, ulongs[i]);
}
Assert.ThrowsException <IndexOutOfRangeException>(() =>
{
var dummy = ulongs[-1];
});
Assert.ThrowsException <IndexOutOfRangeException>(() =>
{
var dummy = ulongs[count];
});
}
public void ListOfSBytesAsListOfStructs()
{
var ds = new DynamicSerializerState(MessageBuilder.Create(128));
ds.SetListOfValues(8, 10);
ds.ListWriteValue(1, (sbyte)-1);
ds.ListWriteValue(2, (sbyte)-2);
ds.ListWriteValue(3, (sbyte)-3);
ds.ListWriteValue(4, (sbyte)-4);
ds.ListWriteValue(5, (sbyte)-5);
ds.ListWriteValue(6, (sbyte)-6);
ds.ListWriteValue(7, (sbyte)-7);
ds.ListWriteValue(8, (sbyte)-8);
ds.ListWriteValue(9, (sbyte)-9);
DeserializerState d = ds;
var asListOfStructs = d.RequireList().Cast(_ => _);
Assert.AreEqual(10, asListOfStructs.Count);
Assert.AreEqual(ObjectKind.Value, asListOfStructs[0].Kind);
Assert.AreEqual((sbyte)0, asListOfStructs[0].ReadDataSByte(0));
Assert.AreEqual((sbyte)-1, asListOfStructs[1].ReadDataSByte(0));
Assert.AreEqual((sbyte)-2, asListOfStructs[2].ReadDataSByte(0));
Assert.AreEqual((sbyte)-3, asListOfStructs[3].ReadDataSByte(0));
Assert.AreEqual((sbyte)-4, asListOfStructs[4].ReadDataSByte(0));
Assert.AreEqual((sbyte)-5, asListOfStructs[5].ReadDataSByte(0));
Assert.AreEqual((sbyte)-6, asListOfStructs[6].ReadDataSByte(0));
Assert.AreEqual((sbyte)-7, asListOfStructs[7].ReadDataSByte(0));
Assert.AreEqual((sbyte)-8, asListOfStructs[8].ReadDataSByte(0));
Assert.AreEqual((sbyte)-9, asListOfStructs[9].ReadDataSByte(0));
}
public void DeserializerStateBadConv()
{
SerializerState s = null;
Assert.ThrowsException <ArgumentNullException>(() => (DeserializerState)s);
s = new DynamicSerializerState();
Assert.ThrowsException <InvalidOperationException>(() => (DeserializerState)s);
}
internal override IPromisedAnswer DoCall(ulong interfaceId, ushort methodId, DynamicSerializerState args, bool pipeline)
{
lock (_question.ReentrancyBlocker)
{
if (_question.StateFlags.HasFlag(PendingQuestion.State.Returned) &&
!_question.StateFlags.HasFlag(PendingQuestion.State.TailCall))
{
if (ResolvedCap == null)
{
throw new RpcException("Answer did not resolve to expected capability");
}
return(CallOnResolution(interfaceId, methodId, args, pipeline));
}
else
{
#if DebugEmbargos
Logger.LogDebug("Call by proxy");
#endif
if (_question.StateFlags.HasFlag(PendingQuestion.State.Disposed))
{
throw new ObjectDisposedException(nameof(PendingQuestion));
}
if (_question.StateFlags.HasFlag(PendingQuestion.State.FinishRequested))
{
throw new InvalidOperationException("Finish request was already sent");
}
_question.DisallowFinish();
++_pendingCallsOnPromise;
var promisedAnswer = base.DoCall(interfaceId, methodId, args, pipeline);
ReAllowFinishWhenDone(promisedAnswer.WhenReturned);
async void DecrementPendingCallsOnPromiseWhenReturned()
{
try
{
await promisedAnswer.WhenReturned;
}
catch
{
}
finally
{
lock (_question.ReentrancyBlocker)
{
--_pendingCallsOnPromise;
}
}
}
DecrementPendingCallsOnPromiseWhenReturned();
return(promisedAnswer);
}
}
}
public void RequireCap1()
{
var dss = DynamicSerializerState.CreateForRpc();
dss.SetStruct(1, 1);
var d = (DeserializerState)dss;
Assert.ThrowsException <DeserializationException>(() => d.RequireCap <ITestInterface>());
}
protected override Call.WRITER SetupMessage(DynamicSerializerState args, ulong interfaceId, ushort methodId)
{
var call = base.SetupMessage(args, interfaceId, methodId);
call.Target.which = MessageTarget.WHICH.ImportedCap;
call.Target.ImportedCap = _remoteId;
return(call);
}
public void PipelineCallDuringDisposal()
{
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout));
SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumNonDbgTimeout);
Assert.AreEqual(1, server.ConnectionCount);
var mock = new ProvidedCapabilityMock();
server.Main = mock;
var main = client.GetMain <BareProxy>();
Assert.IsTrue(main.WhenResolved.WrappedTask.Wait(MediumNonDbgTimeout));
var args = DynamicSerializerState.CreateForRpc();
args.SetStruct(1, 0);
args.WriteData(0, 123456);
IPromisedAnswer answer2;
using (var answer = main.Call(0x1234567812345678, 0x3333, args))
{
Assert.IsTrue(mock.WhenCalled.Wait(MediumNonDbgTimeout));
var pipelined = (BareProxy)CapabilityReflection.CreateProxy <BareProxy>(answer.Access(new MemberAccessPath(new MemberAccessPath.MemberAccess[] { new MemberAccessPath.StructMemberAccess(1) })));
var args2 = DynamicSerializerState.CreateForRpc();
args2.SetStruct(1, 0);
args2.WriteData(0, 654321);
answer2 = pipelined.Call(0x8765432187654321, 0x4444, args2);
}
using (answer2)
{
(var interfaceId, var methodId, var inargs, var ct) = mock.WhenCalled.Result;
var tcs = new TaskCompletionSource <int>();
using (ct.Register(() => tcs.SetResult(0)))
{
Assert.IsTrue(tcs.Task.Wait(MediumNonDbgTimeout));
}
var mock2 = new ProvidedCapabilityMock();
var result = DynamicSerializerState.CreateForRpc();
result.SetStruct(1, 2);
result.WriteData(0, 654321);
uint id = result.ProvideCapability(mock2).Value;
result.LinkToCapability(1, id);
mock.Return.SetResult(result);
Assert.IsTrue(Assert.ThrowsExceptionAsync <TaskCanceledException>(
async() => await answer2.WhenReturned).Wait(MediumNonDbgTimeout));
}
}
}
public void List4D()
{
var mb = MessageBuilder.Create(128);
var alloc = mb.Allocator;
var ds = new DynamicSerializerState(mb);
int d0 = 3;
int d1 = 2;
int d2 = 4;
int d3 = 5;
ds.SetListOfPointers(d0);
for (int i = 0; i < d0; i++)
{
var p = ds.BuildPointer(i);
p.SetListOfPointers(d1);
for (int j = 0; j < d1; j++)
{
var q = p.BuildPointer(j);
q.SetListOfPointers(d2);
for (int k = 0; k < d2; k++)
{
var r = q.BuildPointer(k);
r.SetListOfValues(32, d3);
for (int l = 0; l < d3; l++)
{
r.ListWriteValue(l, (float)(i * j + k * l));
}
}
}
}
DeserializerState d = ds;
var hqube = (IReadOnlyList <object>)d.RequireList().CastND <float>(4);
Assert.AreEqual(hqube.Count, d0);
for (int i = 0; i < d0; i++)
{
var qube = (IReadOnlyList <object>)hqube[i];
Assert.AreEqual(d1, qube.Count);
for (int j = 0; j < d1; j++)
{
var matrix = (IReadOnlyList <object>)qube[j];
Assert.AreEqual(d2, matrix.Count);
for (int k = 0; k < d2; k++)
{
var vector = (IReadOnlyList <float>)matrix[k];
Assert.AreEqual(d3, vector.Count);
for (int l = 0; l < d3; l++)
{
Assert.AreEqual((float)(i * j + k * l), vector[l]);
}
}
}
}
}
protected override Call.WRITER SetupMessage(DynamicSerializerState args, ulong interfaceId, ushort methodId)
{
var call = base.SetupMessage(args, interfaceId, methodId);
call.Target.which = MessageTarget.WHICH.PromisedAnswer;
call.Target.PromisedAnswer.QuestionId = _question.QuestionId;
_access.Serialize(call.Target.PromisedAnswer);
return(call);
}
public void CallReturnAfterClientSideCancel()
{
ExpectingLogOutput = false;
(var server, var client) = SetupClientServerPair();
using (server)
using (client)
{
try
{
Assert.IsTrue(client.WhenConnected.Wait(MediumNonDbgTimeout));
SpinWait.SpinUntil(() => server.ConnectionCount > 0, MediumNonDbgTimeout);
Assert.AreEqual(1, server.ConnectionCount);
var mock = new ProvidedCapabilityMock();
server.Main = mock;
var main = client.GetMain <BareProxy>();
Assert.IsTrue(main.WhenResolved.WrappedTask.Wait(MediumNonDbgTimeout));
var args = DynamicSerializerState.CreateForRpc();
args.SetStruct(1, 0);
args.WriteData(0, 123456);
CancellationToken ctx;
IPromisedAnswer answer;
using (answer = main.Call(0x1234567812345678, 0x3333, args))
{
Assert.IsTrue(mock.WhenCalled.Wait(MediumNonDbgTimeout));
(var interfaceId, var methodId, var inargs, var ct) = mock.WhenCalled.Result;
Assert.AreEqual <ulong>(0x1234567812345678, interfaceId);
Assert.AreEqual <ushort>(0x3333, methodId);
Assert.AreEqual(ObjectKind.Struct, inargs.Kind);
Assert.AreEqual(123456, inargs.ReadDataInt(0));
ctx = ct;
}
Assert.IsTrue(SpinWait.SpinUntil(() => ctx.IsCancellationRequested, MediumNonDbgTimeout));
var mbr = MessageBuilder.Create();
mbr.InitCapTable();
var result = new DynamicSerializerState(mbr);
result.SetStruct(1, 0);
result.WriteData(0, 654321);
mock.Return.SetResult(result);
// Even after the client cancelled the call, the server must still send
// a response.
async Task AwaitWhenReturned() => await answer.WhenReturned;
Assert.IsTrue(AwaitWhenReturned().ContinueWith(t => { }).Wait(MediumNonDbgTimeout));
}
finally
{
ExpectingLogOutput = true;
}
}
}
public void ReadCap()
{
var dss = DynamicSerializerState.CreateForRpc();
dss.SetStruct(0, 1);
dss.LinkObject <ITestInterface>(0, new TestInterfaceImpl2());
var d = (DeserializerState)dss;
Assert.IsNotNull(d.ReadCap(0));
Assert.IsNotNull(d.ReadCap <ITestInterface>(0));
}
public void ListOfULongsAsListOfStructs()
{
var ds = new DynamicSerializerState(MessageBuilder.Create(128));
ds.SetListOfValues(64, 2);
ds.ListWriteValue(1, ulong.MaxValue);
DeserializerState d = ds;
var asListOfStructs = d.RequireList().Cast(_ => _);
Assert.AreEqual(2, asListOfStructs.Count);
Assert.AreEqual(0ul, asListOfStructs[0].ReadDataULong(0));
Assert.AreEqual(ulong.MaxValue, asListOfStructs[1].ReadDataULong(0));
}
public void ListOfStructsAsListOfSBytes()
{
var ds = new DynamicSerializerState(MessageBuilder.Create(128));
ds.SetListOfStructs(2, 1, 0);
ds.ListBuildStruct(1).WriteData(0, sbyte.MinValue);
DeserializerState d = ds;
var asListOfSBytes = d.RequireList().CastSByte();
Assert.AreEqual(2, asListOfSBytes.Count);
Assert.AreEqual((sbyte)0, asListOfSBytes[0]);
Assert.AreEqual(sbyte.MinValue, asListOfSBytes[1]);
}
public void ListOfStructsAsListOfULongs()
{
var ds = new DynamicSerializerState(MessageBuilder.Create(128));
ds.SetListOfStructs(2, 1, 0);
ds.ListBuildStruct(1).WriteData(0, ulong.MaxValue);
DeserializerState d = ds;
var asListOfULongs = d.RequireList().CastULong();
Assert.AreEqual(2, asListOfULongs.Count);
Assert.AreEqual(0ul, asListOfULongs[0]);
Assert.AreEqual(ulong.MaxValue, asListOfULongs[1]);
}
internal override IPromisedAnswer DoCall(ulong interfaceId, ushort methodId, DynamicSerializerState args)
{
lock (_question.ReentrancyBlocker)
{
if (!_question.StateFlags.HasFlag(PendingQuestion.State.TailCall) &&
_question.StateFlags.HasFlag(PendingQuestion.State.Returned))
{
return(CallOnResolution(interfaceId, methodId, args));
}
else
{
#if DebugEmbargos
Logger.LogDebug("Call by proxy");
#endif
if (_question.StateFlags.HasFlag(PendingQuestion.State.CanceledByDispose) ||
_question.StateFlags.HasFlag(PendingQuestion.State.FinishRequested))
{
args.Dispose();
throw new ObjectDisposedException(nameof(PendingQuestion));
}
_question.DisallowFinish();
++_pendingCallsOnPromise;
var promisedAnswer = base.DoCall(interfaceId, methodId, args);
ReAllowFinishWhenDone(promisedAnswer.WhenReturned);
async void DecrementPendingCallsOnPromiseWhenReturned()
{
try
{
await promisedAnswer.WhenReturned;
}
catch
{
}
finally
{
lock (_question.ReentrancyBlocker)
{
--_pendingCallsOnPromise;
}
}
}
DecrementPendingCallsOnPromiseWhenReturned();
return(promisedAnswer);
}
}
}
public void ListOfEmpty()
{
var mb = MessageBuilder.Create(1);
var alloc = mb.Allocator;
var ds = new DynamicSerializerState(mb);
ds.SetListOfValues(0, int.MaxValue);
Assert.ThrowsException <InvalidOperationException>(
() => ds.ListWriteValue(0, 1, 0));
DeserializerState d = ds;
Assert.AreEqual(ObjectKind.ListOfEmpty, d.Kind);
Assert.AreEqual(int.MaxValue, d.ListElementCount);
}
public void ListOfUIntsAsListOfStructs()
{
var ds = new DynamicSerializerState(MessageBuilder.Create(128));
ds.SetListOfValues(32, 2);
ds.ListWriteValue(1, uint.MaxValue);
DeserializerState d = ds;
var asListOfStructs = d.RequireList().Cast(_ => _);
Assert.AreEqual(2, asListOfStructs.Count);
Assert.AreEqual(ObjectKind.Value, asListOfStructs[0].Kind);
Assert.AreEqual(0u, asListOfStructs[0].ReadDataUInt(0));
Assert.AreEqual(uint.MaxValue, asListOfStructs[1].ReadDataUInt(0));
}
protected virtual Call.WRITER SetupMessage(DynamicSerializerState args, ulong interfaceId, ushort methodId)
{
var callMsg = args.MsgBuilder.BuildRoot <Message.WRITER>();
callMsg.which = Message.WHICH.Call;
var call = callMsg.Call;
call.AllowThirdPartyTailCall = false;
call.InterfaceId = interfaceId;
call.MethodId = methodId;
call.Params.Content = args;
return(call);
}
public void ListOfStructsAsListOfDoubles()
{
var ds = new DynamicSerializerState(MessageBuilder.Create(128));
ds.SetListOfStructs(2, 1, 0);
ds.ListBuildStruct(0).WriteData(0, double.NegativeInfinity);
ds.ListBuildStruct(1).WriteData(0, double.MaxValue);
DeserializerState d = ds;
var asListOfDoubles = d.RequireList().CastDouble();
Assert.AreEqual(2, asListOfDoubles.Count);
Assert.AreEqual(double.NegativeInfinity, asListOfDoubles[0]);
Assert.AreEqual(double.MaxValue, asListOfDoubles[1]);
}
public void ListOfStructsAsListOfFloats()
{
var ds = new DynamicSerializerState(MessageBuilder.Create(128));
ds.SetListOfStructs(2, 1, 0);
ds.ListBuildStruct(0).WriteData(0, float.NaN);
ds.ListBuildStruct(1).WriteData(0, float.PositiveInfinity);
DeserializerState d = ds;
var asListOfFloats = d.RequireList().CastFloat();
Assert.AreEqual(2, asListOfFloats.Count);
Assert.AreEqual(float.NaN, asListOfFloats[0]);
Assert.AreEqual(float.PositiveInfinity, asListOfFloats[1]);
}
public void ListOfStructsAsListOfBools()
{
var ds = new DynamicSerializerState(MessageBuilder.Create(128));
ds.SetListOfStructs(3, 1, 0);
ds.ListBuildStruct(1).WriteData(0, false);
ds.ListBuildStruct(2).WriteData(0, true);
DeserializerState d = ds;
var asListOfBools = d.RequireList().CastBool();
Assert.AreEqual(3, asListOfBools.Count);
Assert.AreEqual(false, asListOfBools[0]);
Assert.AreEqual(false, asListOfBools[1]);
Assert.AreEqual(true, asListOfBools[2]);
}
public void ListOfStructsAsListOfBytes()
{
var ds = new DynamicSerializerState(MessageBuilder.Create(128));
ds.SetListOfStructs(3, 1, 0);
ds.ListBuildStruct(1).WriteData(0, (byte)0x11);
ds.ListBuildStruct(2).WriteData(0, (byte)0x22);
DeserializerState d = ds;
var asListOfBytes = d.RequireList().CastByte();
Assert.AreEqual(3, asListOfBytes.Count);
Assert.AreEqual(0, asListOfBytes[0]);
Assert.AreEqual((byte)0x11, asListOfBytes[1]);
Assert.AreEqual((byte)0x22, asListOfBytes[2]);
}
