public unsafe void UnsignedValuesUnsafe()
{
using (var codec = new CodecWriter(BufferSize))
{
foreach (var valList in BatchGroup(TestValuesGenerator(), codec.BufferSize / 10))
{
codec.Count = 0;
foreach (ulong val in valList)
codec.WriteUnsignedValue(val);
fixed(byte *pbuf = codec.Buffer)
{
int pos = 0;
foreach (ulong val in valList)
{
if (val != CodecReader.ReadUnsignedValueUnsafe(pbuf, ref pos))
{
Assert.Fail("Failed ulong {0:X}", val);
}
}
codec.Count = pos;
}
}
}
}
public unsafe void OneValueTest([Values(unchecked ((long)0xFFFFFFFFFF000000UL))] long value)
{
using (var codec = new CodecWriter(10))
{
codec.Count = 0;
codec.WriteSignedValue(value);
fixed(byte *pbuf = codec.Buffer)
{
int pos = 0;
long v = CodecReader.ReadSignedValueUnsafe(pbuf, ref pos);
if (value != v)
{
Assert.Fail("Failed signed long {0:X}", value);
}
}
using (var codecRdr = new CodecReader(codec.AsArraySegment()))
{
long v = codecRdr.ReadSignedValue();
if (value != v)
{
Assert.Fail("Failed signed long {0:X}", value);
}
}
}
}
public unsafe void CompareLoopAndSequenceUnsigned()
{
const int bufSize = BufferSize;
const int valCount = bufSize / 10;
const int runs = 100;
Stopwatch sw;
using (var codec = new CodecWriter(bufSize))
{
ulong[] valList = TestValuesGenerator().Take(valCount).ToArray();
foreach (ulong val in valList)
codec.WriteUnsignedValue(val);
// precache
fixed(byte *buff2 = codec.Buffer)
{
int pos = 0;
CodecReader.ReadSignedValueUnsafe(buff2, ref pos);
CodecReader.ReadUnsignedValueUnsafe(buff2, ref pos);
}
sw = Stopwatch.StartNew();
for (int i = 0; i < runs; i++)
{
fixed(byte *pbuff = codec.Buffer)
{
int pos = 0;
for (int r = 0; r < valCount; r++)
{
CodecReader.ReadSignedValueUnsafe(pbuff, ref pos);
}
}
}
Console.WriteLine("{0} ReadSignedValueUnsafe() time", sw.Elapsed);
sw.Restart();
for (int i = 0; i < runs; i++)
{
fixed(byte *pbuff = codec.Buffer)
{
int pos = 0;
for (int r = 0; r < valCount; r++)
{
CodecReader.ReadUnsignedValueUnsafe(pbuff, ref pos);
}
}
}
}
Console.WriteLine("{0} ReadUnsignedValueUnsafe() time", sw.Elapsed);
}
/// <summary>
/// Encode all values using the given serializer, and than decode them back.
/// </summary>
private static IEnumerable <T> RoundTrip <T>(DynamicSerializer <T> ds, CodecWriter codec, IEnumerable <T> values)
{
using (IEnumerator <T> enmr = values.GetEnumerator())
{
bool moveNext = enmr.MoveNext();
var buff = new Buffer <T>(new T[4]);
while (moveNext)
{
try
{
codec.Count = 0;
moveNext = ds.Serialize(codec, enmr);
codec.Count = 0;
buff.Count = 0;
using (var cdcRdr = new CodecReader(codec.AsArraySegment()))
ds.DeSerialize(cdcRdr, buff, int.MaxValue);
}
catch (Exception x)
{
string msg = string.Format(
"codec.Count={0}, codec.Buffer[pos-1]={1}, enmr.Value={2}",
codec.Count,
codec.Count > 0
? codec.Buffer[codec.Count - 1].ToString(CultureInfo.InvariantCulture)
: "n/a",
moveNext ? enmr.Current.ToString() : "none left");
if (x.GetType() == typeof(OverflowException))
{
throw new OverflowException(msg, x);
}
throw new SerializerException(x, msg);
}
ArraySegment <T> result = buff.AsArraySegment();
for (int i = result.Offset; i < result.Count; i++)
{
yield return(result.Array[i]);
}
}
}
}
public unsafe void ErrorValuesTests()
{
var buf = new byte[10];
for (int i = 0; i < buf.Length; i++)
{
buf[i] = 0xFF;
}
int pos = 0;
// ReSharper disable AccessToModifiedClosure
Assert.Throws <SerializerException>(
() =>
{
fixed(byte *pbuf = buf)
CodecReader.ReadSignedValueUnsafe(pbuf, ref pos);
});
// ReSharper restore AccessToModifiedClosure
Assert.AreEqual(0, pos, "ReadSignedValueUnsafe pos shifted");
Assert.Throws <SerializerException>(
() =>
{
fixed(byte *pbuf = buf)
CodecReader.ReadUnsignedValueUnsafe(pbuf, ref pos);
});
Assert.AreEqual(0, pos, "ReadSignedValueUnsafe pos shifted");
using (var codecRdr = new CodecReader(new ArraySegment <byte>(buf)))
{
// ReSharper disable AccessToDisposedClosure
Assert.Throws <SerializerException>(() => codecRdr.ReadSignedValue());
// ReSharper restore AccessToDisposedClosure
Assert.AreEqual(0, codecRdr.BufferPos, "ReadSignedValue pos shifted");
// ReSharper disable AccessToDisposedClosure
Assert.Throws <SerializerException>(() => codecRdr.ReadUnsignedValue());
// ReSharper restore AccessToDisposedClosure
Assert.AreEqual(0, codecRdr.BufferPos, "ReadUnsignedValue pos shifted");
}
}
public void UnsignedValues()
{
using (var codec = new CodecWriter(BufferSize))
using (var codecRdr = new CodecReader(codec.AsArraySegment()))
{
foreach (var valList in BatchGroup(TestValuesGenerator(), codec.BufferSize / 10))
{
codec.Count = 0;
foreach (ulong val in valList)
{
codec.WriteUnsignedValue(val);
}
codecRdr.AttachBuffer(codec.AsArraySegment());
foreach (ulong val in valList)
{
if (val != codecRdr.ReadUnsignedValue())
{
Assert.Fail("Failed ulong {0:X}", val);
}
}
}
}
}
