protected override object DeserializeObject(ref MessagePackReader reader, Type type, string field)
{
try
{
if (type == typeof(string))
{
return(ReadString(ref reader, "argument"));
}
else if (type == typeof(bool))
{
return(reader.ReadBoolean());
}
else if (type == typeof(int))
{
return(reader.ReadInt32());
}
else if (type == typeof(long))
{
return(reader.ReadInt64());
}
else if (type == typeof(float))
{
return(reader.ReadSingle());
}
}
catch (Exception ex)
{
throw new InvalidDataException($"Deserializing object of the `{type.Name}` type for '{field}' failed.", ex);
}
throw new FormatException($"Type {type} is not supported");
}
internal override long DeserializeContentProcessed(ReadOnlySequence <byte> payload)
{
var reader = new MessagePackReader(payload);
reader.ReadArrayHeader();
return(reader.ReadInt64());
}
public MessageHeader Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
string userName = reader.ReadString();
string messageId = reader.ReadString();
long createTime = reader.ReadInt64();
long requestTime = reader.ReadInt64();
bool isFragmented = reader.ReadBoolean();
bool? firstFragment = MsgPackUtils.ReadNullableBool(ref reader);
bool? lastFragment = MsgPackUtils.ReadNullableBool(ref reader);
int? offset = MsgPackUtils.ReadNullableInt(ref reader);
int? fullDataSize = MsgPackUtils.ReadNullableInt(ref reader);
int dataType = reader.ReadInt32();
return(new MessageHeader(userName, messageId, createTime, requestTime, isFragmented, firstFragment,
lastFragment, offset, fullDataSize, (DataType)dataType));
}
public global::Common.Fix64 Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
throw new InvalidOperationException("typecode is null, struct not supported");
}
options.Security.DepthStep(ref reader);
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __RawValue__ = default(long);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__RawValue__ = reader.ReadInt64();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Common.Fix64(__RawValue__);
____result.RawValue = __RawValue__;
reader.Depth--;
return(____result);
}
public Int64?Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
return(reader.ReadInt64());
}
public global::Server.SharedThings.Packets.Representations.Character Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __Nickname__ = default(string);
var __Authority__ = default(global::Server.SharedThings.Enums.AuthorityType);
var __TimeOfCreation__ = default(global::System.DateTime);
var __LastTimePlayed__ = default(global::System.DateTime);
var __MapId__ = default(long);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__Nickname__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 1:
__Authority__ = formatterResolver.GetFormatterWithVerify <global::Server.SharedThings.Enums.AuthorityType>().Deserialize(ref reader, options);
break;
case 2:
__TimeOfCreation__ = formatterResolver.GetFormatterWithVerify <global::System.DateTime>().Deserialize(ref reader, options);
break;
case 3:
__LastTimePlayed__ = formatterResolver.GetFormatterWithVerify <global::System.DateTime>().Deserialize(ref reader, options);
break;
case 4:
__MapId__ = reader.ReadInt64();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Server.SharedThings.Packets.Representations.Character();
____result.Nickname = __Nickname__;
____result.Authority = __Authority__;
____result.TimeOfCreation = __TimeOfCreation__;
____result.LastTimePlayed = __LastTimePlayed__;
____result.MapId = __MapId__;
return(____result);
}
public RequestId Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.NextMessagePackType == MessagePackType.Integer)
{
return(new RequestId(reader.ReadInt64()));
}
else
{
return(new RequestId(reader.ReadString()));
}
}
public DateTime Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.GetMessagePackType() == MessagePackType.Extension)
{
return(DateTimeFormatter.Instance.Deserialize(ref reader, formatterResolver));
}
var dateData = reader.ReadInt64();
return(DateTime.FromBinary(dateData));
}
public DateTime Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.NextMessagePackType == MessagePackType.Integer)
{
var d = reader.ReadInt64();
return(d.ToDateTime());
}
else
{
return(reader.ReadDateTime());
}
}
internal override Channel.AcceptanceParameters DeserializeAcceptanceParameters(ReadOnlySequence <byte> payload)
{
var reader = new MessagePackReader(payload);
int elementsCount = reader.ReadArrayHeader();
long?remoteWindowSize = null;
if (elementsCount > 0)
{
remoteWindowSize = reader.ReadInt64();
}
return(new Channel.AcceptanceParameters(remoteWindowSize));
}
public Int64[] Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
var len = reader.ReadArrayHeader();
var array = new Int64[len];
for (int i = 0; i < array.Length; i++)
{
array[i] = reader.ReadInt64();
}
return(array);
}
protected override VersionInfoContextInfo? DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
NuGetVersion? nuGetVersion = null;
long? downloadCount = null;
PackageDeprecationMetadataContextInfo? packageDeprecationMetadata = null;
PackageSearchMetadataContextInfo? packageSearchMetadata = null;
int propertyCount = reader.ReadMapHeader();
for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++)
{
switch (reader.ReadString())
{
case NuGetVersionPropertyName:
nuGetVersion = NuGetVersionFormatter.Instance.Deserialize(ref reader, options);
break;
case DownloadCountPropertyName:
if (!reader.TryReadNil())
{
downloadCount = reader.ReadInt64();
}
break;
case PackageDeprecationMetadataPropertyName:
if (!reader.TryReadNil())
{
packageDeprecationMetadata = PackageDeprecationMetadataContextInfoFormatter.Instance.Deserialize(ref reader, options);
}
break;
case PackageSearchMetadataPropertyName:
if (!reader.TryReadNil())
{
packageSearchMetadata = PackageSearchMetadataContextInfoFormatter.Instance.Deserialize(ref reader, options);
}
break;
default:
reader.Skip();
break;
}
}
Assumes.NotNull(nuGetVersion);
return new VersionInfoContextInfo(nuGetVersion, downloadCount)
{
PackageSearchMetadata = packageSearchMetadata,
PackageDeprecationMetadata = packageDeprecationMetadata,
};
}
protected override object DeserializeObject(ref MessagePackReader reader, Type type, string field)
{
try
{
if (type == typeof(string))
{
return(ReadString(ref reader, "argument"));
}
else if (type == typeof(bool))
{
return(reader.ReadBoolean());
}
else if (type == typeof(int))
{
return(reader.ReadInt32());
}
else if (type == typeof(long))
{
return(reader.ReadInt64());
}
else if (type == typeof(float))
{
return(reader.ReadSingle());
}
else if (type == typeof(byte[]))
{
var bytes = reader.ReadBytes();
if (!bytes.HasValue)
{
return(null);
}
else if (bytes.Value.Length == 0)
{
return(Array.Empty <byte>());
}
return(bytes.Value.ToArray());
}
}
catch (Exception ex)
{
throw new InvalidDataException($"Deserializing object of the `{type.Name}` type for '{field}' failed.", ex);
}
throw new FormatException($"Type {type} is not supported");
}
public DateTime[] Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
var len = reader.ReadArrayHeader();
var array = new DateTime[len];
for (int i = 0; i < array.Length; i++)
{
var dateData = reader.ReadInt64();
array[i] = DateTime.FromBinary(dateData);
}
return(array);
}
public QueryRequestData Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
int size = reader.ReadArrayHeader();
string select = reader.ReadString();
ConsistencyType consistency = (ConsistencyType)Enum.Parse(typeof(ConsistencyType), reader.ReadString(), true);
long timeout = reader.ReadInt64();
int?querypagesize = null;
int?querytype = null;
if (size == 5)
{
querypagesize = reader.ReadInt32();
querytype = reader.ReadInt32();
}
return(new QueryRequestData(select, consistency, timeout, querypagesize, (QueryType)querytype));
}
public TraceRecord Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
// Older trace records (N3 RC3 and before) did not have gas consumed value.
// When parsing TraceRecords, if there are only two fields in the TraceRecord array, provide a dummy gasConsumed value.
var fieldCount = reader.ReadArrayHeader();
if (fieldCount != 2 && fieldCount != 3)
{
throw new MessagePackSerializationException($"Invalid TraceRecord Array Header {fieldCount}");
}
var state = options.Resolver.GetFormatterWithVerify <VMState>().Deserialize(ref reader, options);
var gasConsumed = fieldCount == 3 ? reader.ReadInt64() : 0;
var stackFrames = options.Resolver.GetFormatterWithVerify <IReadOnlyList <TraceRecord.StackFrame> >().Deserialize(ref reader, options);
return(new TraceRecord(state, gasConsumed, stackFrames));
}
protected override object DeserializeObject(ref MessagePackReader reader, Type type, string field)
{
try
{
if (type == typeof(string))
{
return(ReadString(ref reader, "argument"));
}
else if (type == typeof(bool))
{
return(reader.ReadBoolean());
}
else if (type == typeof(int))
{
return(reader.ReadInt32());
}
else if (type == typeof(long))
{
return(reader.ReadInt64());
}
else if (type == typeof(float))
{
return(reader.ReadSingle());
}
else if (type == typeof(byte[]))
{
var bytes = reader.ReadBytes();
if (!bytes.HasValue)
{
return(null);
}
else if (bytes.Value.Length == 0)
{
return(Array.Empty <byte>());
}
return(bytes.Value.ToArray());
}
else if (type == typeof(JsonElement))
{
var bytes = reader.ReadBytes();
if (bytes is null)
{
return(default);
public DateTime[] Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
else
{
var len = reader.ReadArrayHeader();
var array = new DateTime[len];
for (int i = 0; i < array.Length; i++)
{
var dateData = reader.ReadInt64();
array[i] = DateTime.FromBinary(dateData);
}
return(array);
}
}
internal override Channel.OfferParameters DeserializeOfferParameters(ReadOnlySequence <byte> payload)
{
var reader = new MessagePackReader(payload);
int elementsCount = reader.ReadArrayHeader();
if (elementsCount == 0)
{
throw new MultiplexingProtocolException("Insufficient elements in offer parameter payload.");
}
string name = reader.ReadString();
long? remoteWindowSize = null;
if (elementsCount > 1)
{
remoteWindowSize = reader.ReadInt64();
}
return(new Channel.OfferParameters(name, remoteWindowSize));
}
private static object DeserializeObject(ref MessagePackReader reader, Type type, string field)
{
try
{
if (type == typeof(string))
{
return(ReadString(ref reader, "argument"));
}
else if (type == typeof(bool))
{
return(reader.ReadBoolean());
}
else if (type == typeof(int))
{
return(reader.ReadInt32());
}
else if (type == typeof(long))
{
return(reader.ReadInt64());
}
else if (type == typeof(float))
{
return(reader.ReadSingle());
}
else if (type == typeof(byte[]))
{
var bytes = reader.ReadBytes();
// MessagePack ensures there are at least as many bytes in the message as declared by the byte header.
// Consequently it is safe to do ToArray on the returned SequenceReader instance.
return(bytes.ToArray());
}
}
catch (Exception ex)
{
throw new InvalidDataException($"Deserializing object of the `{type.Name}` type for '{field}' failed.", ex);
}
throw new FormatException($"Type {type} is not supported");
}
public void Int64Test(long target, int length)
{
(MemoryStream stream, MsgPack.Packer packer) = this.CreateReferencePacker();
var sequence = new Sequence <byte>();
var writer = new MessagePackWriter(sequence);
writer.Write(target);
writer.Flush();
sequence.Length.Is(length);
// bug of msgpack-cli
if (target == 255)
{
packer.Pack((byte)255).Position.Is(sequence.Length);
}
else if (target == 50000)
{
packer.Pack((ushort)50000).Position.Is(sequence.Length);
}
else if (target == uint.MaxValue)
{
packer.Pack(uint.MaxValue).Position.Is(sequence.Length);
}
else
{
packer.Pack(target).Position.Is(sequence.Length);
}
//// stream.ToArray().SequenceEqual(sequence.AsReadOnlySequence.ToArray()).IsTrue();
var sequenceReader = new MessagePackReader(sequence.AsReadOnlySequence);
sequenceReader.ReadInt64().Is(target);
sequenceReader.End.IsTrue();
this.CreateUnpackedReference(sequence).AsInt64().Is(target);
}
public Period Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
return(null);
}
var count = reader.ReadArrayHeader();
if (count != 10)
{
throw new InvalidOperationException("Invalid array count");
}
var years = reader.ReadInt32();
var months = reader.ReadInt32();
var weeks = reader.ReadInt32();
var days = reader.ReadInt32();
var hours = reader.ReadInt64();
var minutes = reader.ReadInt64();
var seconds = reader.ReadInt64();
var milliseconds = reader.ReadInt64();
var ticks = reader.ReadInt64();
var nano = reader.ReadInt64();
return(new PeriodBuilder()
{
Years = years,
Months = months,
Weeks = weeks,
Days = days,
Hours = hours,
Minutes = minutes,
Seconds = seconds,
Milliseconds = milliseconds,
Ticks = ticks,
Nanoseconds = nano,
}
.Build());
}
public TimeSpan Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(new TimeSpan(reader.ReadInt64()));
}
public LocalTime Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
var nanos = reader.ReadInt64();
return(LocalTime.Midnight.PlusNanoseconds(nanos));
}
public object Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
MessagePackType type = reader.NextMessagePackType;
IFormatterResolver resolver = options.Resolver;
switch (type)
{
case MessagePackType.Integer:
var code = reader.NextCode;
if (code >= MessagePackCode.MinNegativeFixInt && code <= MessagePackCode.MaxNegativeFixInt)
{
return(reader.ReadSByte());
}
else if (code >= MessagePackCode.MinFixInt && code <= MessagePackCode.MaxFixInt)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.Int8)
{
return(reader.ReadSByte());
}
else if (code == MessagePackCode.Int16)
{
return(reader.ReadInt16());
}
else if (code == MessagePackCode.Int32)
{
return(reader.ReadInt32());
}
else if (code == MessagePackCode.Int64)
{
return(reader.ReadInt64());
}
else if (code == MessagePackCode.UInt8)
{
return(reader.ReadByte());
}
else if (code == MessagePackCode.UInt16)
{
return(reader.ReadUInt16());
}
else if (code == MessagePackCode.UInt32)
{
return(reader.ReadUInt32());
}
else if (code == MessagePackCode.UInt64)
{
return(reader.ReadUInt64());
}
throw new MessagePackSerializationException("Invalid primitive bytes.");
case MessagePackType.Boolean:
return(reader.ReadBoolean());
case MessagePackType.Float:
if (reader.NextCode == MessagePackCode.Float32)
{
return(reader.ReadSingle());
}
else
{
return(reader.ReadDouble());
}
case MessagePackType.String:
return(reader.ReadString());
case MessagePackType.Binary:
// We must copy the sequence returned by ReadBytes since the reader's sequence is only valid during deserialization.
return(reader.ReadBytes()?.ToArray());
case MessagePackType.Extension:
ExtensionHeader ext = reader.ReadExtensionFormatHeader();
if (ext.TypeCode == ReservedMessagePackExtensionTypeCode.DateTime)
{
return(reader.ReadDateTime(ext));
}
throw new MessagePackSerializationException("Invalid primitive bytes.");
case MessagePackType.Array:
{
var length = reader.ReadArrayHeader();
if (length == 0)
{
return(Array.Empty <object>());
}
IMessagePackFormatter <object> objectFormatter = resolver.GetFormatter <object>();
var array = new object[length];
options.Security.DepthStep(ref reader);
try
{
for (int i = 0; i < length; i++)
{
array[i] = objectFormatter.Deserialize(ref reader, options);
}
}
finally
{
reader.Depth--;
}
return(array);
}
case MessagePackType.Map:
{
var length = reader.ReadMapHeader();
IMessagePackFormatter <object> objectFormatter = resolver.GetFormatter <object>();
var hash = new Dictionary <object, object>(length, options.Security.GetEqualityComparer <object>());
options.Security.DepthStep(ref reader);
try
{
for (int i = 0; i < length; i++)
{
var key = objectFormatter.Deserialize(ref reader, options);
var value = objectFormatter.Deserialize(ref reader, options);
hash.Add(key, value);
}
}
finally
{
reader.Depth--;
}
return(hash);
}
case MessagePackType.Nil:
reader.ReadNil();
return(null);
default:
throw new MessagePackSerializationException("Invalid primitive bytes.");
}
}
public DateTime Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
var dateData = reader.ReadInt64();
return(DateTime.FromBinary(dateData));
}
public DateTime Deserialize(ref MessagePackReader reader, IFormatterResolver resolver)
{
var dateData = reader.ReadInt64();
return(DateTime.FromBinary(dateData));
}
public TimeSpan Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
return(new TimeSpan(reader.ReadInt64()));
}
public void ForceBlockFormatters()
{
var block = new BlockFormattedIntegers
{
UInt8Property = 1,
UInt16Property = 2,
UInt32Property = 3,
UInt64Property = 4,
Int8Property = 1,
Int16Property = 2,
Int32Property = 3,
Int64Property = 4,
NullableUInt8Property = 1,
NullableUInt16Property = 2,
NullableUInt32Property = 3,
NullableUInt64Property = 4,
NullableInt8Property = 1,
NullableInt16Property = 2,
NullableInt32Property = 3,
NullableInt64Property = 4,
};
byte[] packed = MessagePackSerializer.Serialize(block, MessagePackSerializerOptions.Standard);
var reader = new MessagePackReader(packed);
reader.ReadArrayHeader();
Assert.Equal(MessagePackCode.UInt8, reader.NextCode);
Assert.Equal(1, reader.ReadByte());
Assert.Equal(MessagePackCode.UInt16, reader.NextCode);
Assert.Equal(2, reader.ReadUInt16());
Assert.Equal(MessagePackCode.UInt32, reader.NextCode);
Assert.Equal(3u, reader.ReadUInt32());
Assert.Equal(MessagePackCode.UInt64, reader.NextCode);
Assert.Equal(4u, reader.ReadUInt64());
Assert.Equal(MessagePackCode.Int8, reader.NextCode);
Assert.Equal(1, reader.ReadSByte());
Assert.Equal(MessagePackCode.Int16, reader.NextCode);
Assert.Equal(2, reader.ReadInt16());
Assert.Equal(MessagePackCode.Int32, reader.NextCode);
Assert.Equal(3, reader.ReadInt32());
Assert.Equal(MessagePackCode.Int64, reader.NextCode);
Assert.Equal(4, reader.ReadInt64());
Assert.Equal(MessagePackCode.UInt8, reader.NextCode);
Assert.Equal(1, reader.ReadByte());
Assert.Equal(MessagePackCode.UInt16, reader.NextCode);
Assert.Equal(2, reader.ReadUInt16());
Assert.Equal(MessagePackCode.UInt32, reader.NextCode);
Assert.Equal(3u, reader.ReadUInt32());
Assert.Equal(MessagePackCode.UInt64, reader.NextCode);
Assert.Equal(4u, reader.ReadUInt64());
Assert.Equal(MessagePackCode.Int8, reader.NextCode);
Assert.Equal(1, reader.ReadSByte());
Assert.Equal(MessagePackCode.Int16, reader.NextCode);
Assert.Equal(2, reader.ReadInt16());
Assert.Equal(MessagePackCode.Int32, reader.NextCode);
Assert.Equal(3, reader.ReadInt32());
Assert.Equal(MessagePackCode.Int64, reader.NextCode);
Assert.Equal(4, reader.ReadInt64());
}
public void IntegerRangeTest()
{
// Int16 can accepts UInt8
// Int32 can accepts UInt16
// Int64 can accepts UInt32
{
var small = new Sequence <byte>();
var smallWriter = new MessagePackWriter(small);
smallWriter.Write(byte.MaxValue);
smallWriter.Flush();
var smallReader = new MessagePackReader(small.AsReadOnlySequence);
smallReader.ReadInt16().Is(byte.MaxValue);
var target = new Sequence <byte>();
var targetWriter = new MessagePackWriter(target);
targetWriter.Write((short)byte.MaxValue);
targetWriter.Flush();
target.AsReadOnlySequence.ToArray().SequenceEqual(small.AsReadOnlySequence.ToArray()).IsTrue();
}
{
var small = new Sequence <byte>();
var smallWriter = new MessagePackWriter(small);
smallWriter.Write(byte.MaxValue);
smallWriter.Flush();
var smallReader = new MessagePackReader(small.AsReadOnlySequence);
smallReader.ReadInt32().Is(byte.MaxValue);
var target = new Sequence <byte>();
var targetWriter = new MessagePackWriter(target);
targetWriter.Write((int)byte.MaxValue);
targetWriter.Flush();
target.AsReadOnlySequence.ToArray().SequenceEqual(small.AsReadOnlySequence.ToArray()).IsTrue();
small.Reset();
smallWriter = new MessagePackWriter(small);
smallWriter.Write(ushort.MaxValue);
smallWriter.Flush();
smallReader = new MessagePackReader(small.AsReadOnlySequence);
smallReader.ReadInt32().Is(ushort.MaxValue);
target.Reset();
targetWriter = new MessagePackWriter(target);
targetWriter.Write((int)ushort.MaxValue);
targetWriter.Flush();
target.AsReadOnlySequence.ToArray().SequenceEqual(small.AsReadOnlySequence.ToArray()).IsTrue();
}
{
var small = new Sequence <byte>();
var smallWriter = new MessagePackWriter(small);
smallWriter.Write(byte.MaxValue);
smallWriter.Flush();
var smallReader = new MessagePackReader(small.AsReadOnlySequence);
smallReader.ReadInt64().Is(byte.MaxValue);
var target = new Sequence <byte>();
var targetWriter = new MessagePackWriter(target);
targetWriter.Write((long)byte.MaxValue);
targetWriter.Flush();
target.AsReadOnlySequence.ToArray().SequenceEqual(small.AsReadOnlySequence.ToArray()).IsTrue();
small.Reset();
smallWriter = new MessagePackWriter(small);
smallWriter.Write(ushort.MaxValue);
smallWriter.Flush();
smallReader = new MessagePackReader(small.AsReadOnlySequence);
smallReader.ReadInt64().Is(ushort.MaxValue);
target.Reset();
targetWriter = new MessagePackWriter(target);
targetWriter.Write((long)ushort.MaxValue);
targetWriter.Flush();
target.AsReadOnlySequence.ToArray().SequenceEqual(small.AsReadOnlySequence.ToArray()).IsTrue();
small.Reset();
smallWriter = new MessagePackWriter(small);
smallWriter.Write(uint.MaxValue);
smallWriter.Flush();
smallReader = new MessagePackReader(small.AsReadOnlySequence);
smallReader.ReadInt64().Is(uint.MaxValue);
target.Reset();
targetWriter = new MessagePackWriter(target);
targetWriter.Write((long)uint.MaxValue);
targetWriter.Flush();
target.AsReadOnlySequence.ToArray().SequenceEqual(small.AsReadOnlySequence.ToArray()).IsTrue();
}
}