public void TestFloat32()
{
//using (var stream = new MemoryStream())
{
float f;
Buffer stream = new Buffer();
Serializer serializer = new Serializer(stream);
Deserializer deserializer = new Deserializer(stream);
// Boundary value tests
serializer.Write(0.0F);
serializer.Write(Single.Epsilon);
serializer.Write(Single.MinValue);
serializer.Write(Single.MaxValue);
serializer.Write(Single.NegativeInfinity);
serializer.Write(Single.PositiveInfinity);
serializer.Write(Single.NaN);
stream.Rewind();
//stream.Seek(0, SeekOrigin.Begin);
deserializer.Read(out f);
Assert.AreEqual(0.0F, f);
deserializer.Read(out f);
Assert.AreEqual(Single.Epsilon, f);
deserializer.Read(out f);
Assert.AreEqual(Single.MinValue, f);
deserializer.Read(out f);
Assert.AreEqual(Single.MaxValue, f);
deserializer.Read(out f);
Assert.AreEqual(Single.NegativeInfinity, f);
deserializer.Read(out f);
Assert.AreEqual(Single.PositiveInfinity, f);
deserializer.Read(out f);
Assert.AreEqual(Single.NaN, f);
stream.Trim();
//stream.SetLength(0);
// Intermediate value tests
serializer.Write(0.001234F);
serializer.Write(8765.4321F);
stream.Rewind();
//stream.Seek(0, SeekOrigin.Begin);
deserializer.Read(out f);
Assert.AreEqual(0.001234F, f);
deserializer.Read(out f);
Assert.AreEqual(8765.4321F, f);
}
}
public void TestTransform()
{
BlockCipher cipher1 = new BlockCipher();
BlockCipher cipher2 = new BlockCipher();
byte[] bytes1 = cipher1.InitializeHandshake();
byte[] bytes2 = cipher2.InitializeHandshake();
bytes1 = cipher2.Handshake(bytes1);
bytes2 = cipher1.Handshake(bytes2);
cipher1.FinalizeHandshake(bytes1);
cipher2.FinalizeHandshake(bytes2);
var buffer = new x2.Buffer();
string text = new String('x', 5300);
Assert.AreEqual(5300, text.Length);
/*
buffer.Write(1);
buffer.Write(text);
buffer.Shrink(1);
*/
cipher1.Transform(buffer, (int)buffer.Length);
cipher2.InverseTransform(buffer, (int)buffer.Length);
buffer.Rewind();
/*
string result;
buffer.Read(out result);
Assert.AreEqual(text, result);
*/
}
public void TestFloat32()
{
var buffer = new Buffer(1);
// Boundary value tests
buffer.Write(0.0F);
buffer.Write(Single.Epsilon);
buffer.Write(Single.MinValue);
buffer.Write(Single.MaxValue);
buffer.Write(Single.NegativeInfinity);
buffer.Write(Single.PositiveInfinity);
buffer.Write(Single.NaN);
buffer.Rewind();
float f;
buffer.Read(out f);
Assert.AreEqual(0.0F, f);
buffer.Read(out f);
Assert.AreEqual(Single.Epsilon, f);
buffer.Read(out f);
Assert.AreEqual(Single.MinValue, f);
buffer.Read(out f);
Assert.AreEqual(Single.MaxValue, f);
buffer.Read(out f);
Assert.AreEqual(Single.NegativeInfinity, f);
buffer.Read(out f);
Assert.AreEqual(Single.PositiveInfinity, f);
buffer.Read(out f);
Assert.AreEqual(Single.NaN, f);
buffer.Trim();
// Intermediate value tests
buffer.Write(0.001234F);
buffer.Write(8765.4321F);
buffer.Rewind();
buffer.Read(out f);
Assert.AreEqual(0.001234F, f);
buffer.Read(out f);
Assert.AreEqual(8765.4321F, f);
}
public void TestFloat64()
{
var buffer = new Buffer(2);
// Boundary value tests
buffer.Write(0.0D);
buffer.Write(Double.Epsilon);
buffer.Write(Double.MinValue);
buffer.Write(Double.MaxValue);
buffer.Write(Double.NegativeInfinity);
buffer.Write(Double.PositiveInfinity);
buffer.Write(Double.NaN);
buffer.Rewind();
double d;
buffer.Read(out d);
Assert.AreEqual(0.0D, d);
buffer.Read(out d);
Assert.AreEqual(Double.Epsilon, d);
buffer.Read(out d);
Assert.AreEqual(Double.MinValue, d);
buffer.Read(out d);
Assert.AreEqual(Double.MaxValue, d);
buffer.Read(out d);
Assert.AreEqual(Double.NegativeInfinity, d);
buffer.Read(out d);
Assert.AreEqual(Double.PositiveInfinity, d);
buffer.Read(out d);
Assert.AreEqual(Double.NaN, d);
buffer.Trim();
// Intermediate value tests
buffer.Write(0.00123456789D);
buffer.Write(98765.0004321D);
buffer.Rewind();
buffer.Read(out d);
Assert.AreEqual(0.00123456789D, d);
buffer.Read(out d);
Assert.AreEqual(98765.0004321D, d);
}
public int Transform(Buffer buffer, int length)
{
Log.Trace("BlockCipher.Transform: input length {0}", length);
using (var encryptor = encryptionAlgorithm.CreateEncryptor(encryptionKey, encryptionIV))
using (var ms = new MemoryStream(length + BlockSizeInBytes))
using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
{
#if UNITY_WORKAROUND
// Workaround for ancient mono 2.0 of Unity3D
// Multiple Write() calls are not properly handled there.
byte[] plaintext = buffer.ToArray();
if (Log.Level <= LogLevel.Trace)
{
Log.Trace("BlockCipher.Transform: input {0}",
BitConverter.ToString(plaintext, plaintext.Length - length, length));
}
cs.Write(plaintext, plaintext.Length - length, length);
#else
var buffers = new List<ArraySegment<byte>>();
buffer.ListEndingSegments(buffers, length);
for (var i = 0; i < buffers.Count; ++i)
{
var segment = buffers[i];
if (Log.Level <= LogLevel.Trace)
{
Log.Trace("BlockCipher.Transform: input block {0}",
BitConverter.ToString(segment.Array, segment.Offset, segment.Count));
}
cs.Write(segment.Array, segment.Offset, segment.Count);
}
#endif
cs.FlushFinalBlock();
int result = (int)ms.Length;
var streamBuffer = ms.GetBuffer();
if (Log.Level <= LogLevel.Trace)
{
Log.Trace("BlockCipher.Transform: output {0} {1}",
result, BitConverter.ToString(streamBuffer, 0, result));
}
buffer.Rewind();
buffer.CopyFrom(streamBuffer, 0, result);
// Store the last ciphertext block as a next encryption IV.
System.Buffer.BlockCopy(streamBuffer, result - BlockSizeInBytes,
encryptionIV, 0, BlockSizeInBytes);
return result;
}
}
public int InverseTransform(Buffer buffer, int length)
{
Log.Trace("BlockCipher.InverseTransform: input length {0}", length);
using (var decryptor = decryptionAlgorithm.CreateDecryptor(decryptionKey, decryptionIV))
using (var ms = new MemoryStream(length))
using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write))
{
#if UNITY_WORKAROUND
// Workaround for ancient mono 2.0 of Unity3D
// Multiple Write() calls are not properly handled there.
byte[] ciphertext = buffer.ToArray();
if (Log.Level <= LogLevel.Trace)
{
Log.Trace("BlockCipher.InverseTransform: input {0}",
BitConverter.ToString(ciphertext, 0, length));
}
System.Buffer.BlockCopy(ciphertext, length - BlockSizeInBytes,
decryptionIV, 0, BlockSizeInBytes);
cs.Write(ciphertext, 0, length);
#else
var buffers = new List<ArraySegment<byte>>();
buffer.ListStartingSegments(buffers, length);
// Store the last ciphertext block as a next decryption IV.
byte[] nextIV = new byte[BlockSizeInBytes];
int bytesCopied = 0;
for (var i = buffers.Count - 1; bytesCopied < BlockSizeInBytes && i >= 0; --i)
{
var segment = buffers[i];
int bytesToCopy = Math.Min(segment.Count, BlockSizeInBytes);
System.Buffer.BlockCopy(segment.Array, segment.Offset + segment.Count - bytesToCopy,
decryptionIV, BlockSizeInBytes - bytesCopied - bytesToCopy, bytesToCopy);
bytesCopied += bytesToCopy;
}
for (var i = 0; i < buffers.Count; ++i)
{
var segment = buffers[i];
if (Log.Level <= LogLevel.Trace)
{
Log.Trace("BlockCipher.InverseTransform: input block {0}",
BitConverter.ToString(segment.Array, segment.Offset, segment.Count));
}
cs.Write(segment.Array, segment.Offset, segment.Count);
}
#endif
cs.FlushFinalBlock();
int result = (int)ms.Length;
var streamBuffer = ms.GetBuffer();
if (Log.Level <= LogLevel.Trace)
{
Log.Trace("BlockCipher.InverseTransform: output {0} {1}",
result, BitConverter.ToString(streamBuffer, 0, result));
}
buffer.Rewind();
buffer.CopyFrom(streamBuffer, 0, result);
return result;
}
}
public void TestSerialization()
{
Fingerprint fp1 = new Fingerprint(65);
Fingerprint fp2 = new Fingerprint(65);
fp1.Touch(0);
fp1.Touch(2);
fp1.Touch(31);
fp1.Touch(32);
Assert.False(fp2.Equals(fp1));
var buffer = new x2.Buffer();
fp1.Serialize(new Serializer(buffer));
buffer.Rewind();
fp2.Deserialize(new Deserializer(buffer));
Assert.True(fp2.Equals(fp1));
}
public void TestVariableLengthInt64()
{
//using (var stream = new MemoryStream())
{
long l, bytes;
Buffer stream = new Buffer();
Serializer serializer = new Serializer(stream);
Deserializer deserializer = new Deserializer(stream);
// Boundary value tests
serializer.Write(0L);
serializer.Write(-1L);
serializer.Write(Int64.MaxValue);
serializer.Write(Int64.MinValue);
stream.Rewind();
//stream.Seek(0, SeekOrigin.Begin);
bytes = deserializer.Read(out l);
Assert.AreEqual(1, bytes);
Assert.AreEqual(0L, l);
bytes = deserializer.Read(out l);
Assert.AreEqual(1, bytes);
Assert.AreEqual(-1L, l);
bytes = deserializer.Read(out l);
Assert.AreEqual(10, bytes);
Assert.AreEqual(Int64.MaxValue, l);
bytes = deserializer.Read(out l);
Assert.AreEqual(10, bytes);
Assert.AreEqual(Int64.MinValue, l);
stream.Trim();
//stream.SetLength(0);
// Intermediate value tests
serializer.Write(0x00003f80L >> 1); // 2
serializer.Write(0x001fc000L >> 1); // 3
serializer.Write(0x0fe00000L >> 1); // 4
serializer.Write(0x00000007f0000000L >> 1); // 5
serializer.Write(0x000003f800000000L >> 1); // 6
serializer.Write(0x0001fc0000000000L >> 1); // 7
serializer.Write(0x00fe000000000000L >> 1); // 8
serializer.Write(0x7f00000000000000L >> 1); // 9
stream.Rewind();
//stream.Seek(0, SeekOrigin.Begin);
bytes = deserializer.Read(out l);
Assert.AreEqual(2, bytes);
Assert.AreEqual(0x00003f80L >> 1, l);
bytes = deserializer.Read(out l);
Assert.AreEqual(3, bytes);
Assert.AreEqual(0x001fc000L >> 1, l);
bytes = deserializer.Read(out l);
Assert.AreEqual(4, bytes);
Assert.AreEqual(0x0fe00000L >> 1, l);
bytes = deserializer.Read(out l);
Assert.AreEqual(5, bytes);
Assert.AreEqual(0x00000007f0000000L >> 1, l);
bytes = deserializer.Read(out l);
Assert.AreEqual(6, bytes);
Assert.AreEqual(0x000003f800000000L >> 1, l);
bytes = deserializer.Read(out l);
Assert.AreEqual(7, bytes);
Assert.AreEqual(0x0001fc0000000000L >> 1, l);
bytes = deserializer.Read(out l);
Assert.AreEqual(8, bytes);
Assert.AreEqual(0x00fe000000000000L >> 1, l);
bytes = deserializer.Read(out l);
Assert.AreEqual(9, bytes);
Assert.AreEqual(0x7f00000000000000L >> 1, l);
}
}
public void TestVariableLengthInt32()
{
//using (var stream = new MemoryStream())
{
int i, bytes;
Buffer stream = new Buffer();
Serializer serializer = new Serializer(stream);
Deserializer deserializer = new Deserializer(stream);
// Boundary value tests
serializer.Write(0);
serializer.Write(-1);
serializer.Write(Int32.MaxValue);
serializer.Write(Int32.MinValue);
stream.Rewind();
//stream.Seek(0, SeekOrigin.Begin);
bytes = deserializer.Read(out i);
Assert.AreEqual(1, bytes);
Assert.AreEqual(0, i);
bytes = deserializer.Read(out i);
Assert.AreEqual(1, bytes);
Assert.AreEqual(-1, i);
bytes = deserializer.Read(out i);
Assert.AreEqual(5, bytes);
Assert.AreEqual(Int32.MaxValue, i);
bytes = deserializer.Read(out i);
Assert.AreEqual(5, bytes);
Assert.AreEqual(Int32.MinValue, i);
stream.Trim();
//stream.SetLength(0);
// Intermediate value tests
serializer.Write(0x00003f80 >> 1); // 2
serializer.Write(0x001fc000 >> 1); // 3
serializer.Write(0x0fe00000 >> 1); // 4
stream.Rewind();
//stream.Seek(0, SeekOrigin.Begin);
bytes = deserializer.Read(out i);
Assert.AreEqual(2, bytes);
Assert.AreEqual(0x00003f80 >> 1, i);
bytes = deserializer.Read(out i);
Assert.AreEqual(3, bytes);
Assert.AreEqual(0x001fc000 >> 1, i);
bytes = deserializer.Read(out i);
Assert.AreEqual(4, bytes);
Assert.AreEqual(0x0fe00000 >> 1, i);
}
}
public void TestVariableLengthInt64()
{
var buffer = new Buffer(2);
// Boundary value tests
buffer.Write(0L);
buffer.Write(-1L);
buffer.Write(Int64.MaxValue);
buffer.Write(Int64.MinValue);
buffer.Rewind();
long l, bytes;
bytes = buffer.Read(out l);
Assert.AreEqual(1, bytes);
Assert.AreEqual(0L, l);
bytes = buffer.Read(out l);
Assert.AreEqual(1, bytes);
Assert.AreEqual(-1L, l);
bytes = buffer.Read(out l);
Assert.AreEqual(10, bytes);
Assert.AreEqual(Int64.MaxValue, l);
bytes = buffer.Read(out l);
Assert.AreEqual(10, bytes);
Assert.AreEqual(Int64.MinValue, l);
buffer.Trim();
// Intermediate value tests
buffer.Write(0x00003f80L >> 1); // 2
buffer.Write(0x001fc000L >> 1); // 3
buffer.Write(0x0fe00000L >> 1); // 4
buffer.Write(0x00000007f0000000L >> 1); // 5
buffer.Write(0x000003f800000000L >> 1); // 6
buffer.Write(0x0001fc0000000000L >> 1); // 7
buffer.Write(0x00fe000000000000L >> 1); // 8
buffer.Write(0x7f00000000000000L >> 1); // 9
buffer.Rewind();
bytes = buffer.Read(out l);
Assert.AreEqual(2, bytes);
Assert.AreEqual(0x00003f80L >> 1, l);
bytes = buffer.Read(out l);
Assert.AreEqual(3, bytes);
Assert.AreEqual(0x001fc000L >> 1, l);
bytes = buffer.Read(out l);
Assert.AreEqual(4, bytes);
Assert.AreEqual(0x0fe00000L >> 1, l);
bytes = buffer.Read(out l);
Assert.AreEqual(5, bytes);
Assert.AreEqual(0x00000007f0000000L >> 1, l);
bytes = buffer.Read(out l);
Assert.AreEqual(6, bytes);
Assert.AreEqual(0x000003f800000000L >> 1, l);
bytes = buffer.Read(out l);
Assert.AreEqual(7, bytes);
Assert.AreEqual(0x0001fc0000000000L >> 1, l);
bytes = buffer.Read(out l);
Assert.AreEqual(8, bytes);
Assert.AreEqual(0x00fe000000000000L >> 1, l);
bytes = buffer.Read(out l);
Assert.AreEqual(9, bytes);
Assert.AreEqual(0x7f00000000000000L >> 1, l);
}
public void TestVariableLengthInt32()
{
var buffer = new Buffer(2);
// Boundary value tests
buffer.Write(0);
buffer.Write(-1);
buffer.Write(Int32.MaxValue);
buffer.Write(Int32.MinValue);
buffer.Rewind();
int i, bytes;
bytes = buffer.Read(out i);
Assert.AreEqual(1, bytes);
Assert.AreEqual(0, i);
bytes = buffer.Read(out i);
Assert.AreEqual(1, bytes);
Assert.AreEqual(-1, i);
bytes = buffer.Read(out i);
Assert.AreEqual(5, bytes);
Assert.AreEqual(Int32.MaxValue, i);
bytes = buffer.Read(out i);
Assert.AreEqual(5, bytes);
Assert.AreEqual(Int32.MinValue, i);
buffer.Trim();
// Intermediate value tests
buffer.Write(0x00003f80 >> 1); // 2
buffer.Write(0x001fc000 >> 1); // 3
buffer.Write(0x0fe00000 >> 1); // 4
buffer.Rewind();
bytes = buffer.Read(out i);
Assert.AreEqual(2, bytes);
Assert.AreEqual(0x00003f80 >> 1, i);
bytes = buffer.Read(out i);
Assert.AreEqual(3, bytes);
Assert.AreEqual(0x001fc000 >> 1, i);
bytes = buffer.Read(out i);
Assert.AreEqual(4, bytes);
Assert.AreEqual(0x0fe00000 >> 1, i);
}
public void TestSerialization()
{
Fingerprint fp1 = new Fingerprint(65);
Fingerprint fp2 = new Fingerprint(65);
fp1.Touch(0);
fp1.Touch(2);
fp1.Touch(31);
fp1.Touch(32);
Assert.False(fp2.Equals(fp1));
Buffer buffer = new Buffer(12);
fp1.Dump(buffer);
buffer.Rewind();
fp2.Load(buffer);
Assert.True(fp2.Equals(fp1));
}
public void TestFloat64()
{
//using (var stream = new MemoryStream())
{
double d;
var stream = new x2.Buffer();
Serializer serializer = new Serializer(stream);
Deserializer deserializer = new Deserializer(stream);
// Boundary value tests
serializer.Write(0.0);
serializer.Write(Double.Epsilon);
serializer.Write(Double.MinValue);
serializer.Write(Double.MaxValue);
serializer.Write(Double.NegativeInfinity);
serializer.Write(Double.PositiveInfinity);
serializer.Write(Double.NaN);
stream.Rewind();
//stream.Seek(0, SeekOrigin.Begin);
deserializer.Read(out d);
Assert.AreEqual(0.0, d);
deserializer.Read(out d);
Assert.AreEqual(Double.Epsilon, d);
deserializer.Read(out d);
Assert.AreEqual(Double.MinValue, d);
deserializer.Read(out d);
Assert.AreEqual(Double.MaxValue, d);
deserializer.Read(out d);
Assert.AreEqual(Double.NegativeInfinity, d);
deserializer.Read(out d);
Assert.AreEqual(Double.PositiveInfinity, d);
deserializer.Read(out d);
Assert.AreEqual(Double.NaN, d);
stream.Trim();
//stream.SetLength(0);
// Intermediate value tests
serializer.Write(0.001234);
serializer.Write(8765.4321);
stream.Rewind();
//stream.Seek(0, SeekOrigin.Begin);
deserializer.Read(out d);
Assert.AreEqual(0.001234, d);
deserializer.Read(out d);
Assert.AreEqual(8765.4321, d);
}
}
public void TestPartialSerialization()
{
EventFactory.Register<SampleEvent5>();
var buffer = new x2.Buffer();
var cell1 = new SampleCell1 { // base
Foo = 9,
Bar = "hello"
};
var cell2 = new SampleCell2 { // derived
Foo = 9,
Bar = "hello",
Baz = true
};
var event1 = new SampleEvent5(); // has base
// base > base > base
event1.SampleCell = cell1;
Serializer serializer = new Serializer(buffer);
serializer.Write(event1.GetTypeId());
event1.Serialize(serializer);
long bufferLength = buffer.Length;
buffer.Rewind();
Deserializer deserializer = new Deserializer(buffer);
var retrieved = deserializer.Create();
retrieved.Deserialize(deserializer);
var event11 = retrieved as SampleEvent5;
Assert.NotNull(event11);
Assert.AreEqual(event1.SampleCell.Foo, event11.SampleCell.Foo);
Assert.AreEqual(event1.SampleCell.Bar, event11.SampleCell.Bar);
buffer.Reset();
// derived > base > base
event1.SampleCell = cell2; // base <= derived
serializer = new Serializer(buffer);
serializer.Write(event1.GetTypeId());
event1.Serialize(serializer);
Assert.AreEqual(bufferLength, buffer.Length);
{
var event2 = new SampleEvent6(); // has derived
event2.SampleCell = cell2; // derived <= derived
var buffer2 = new x2.Buffer();
serializer = new Serializer(buffer2);
serializer.Write(event2.GetTypeId());
event2.Serialize(serializer);
Assert.Greater(buffer2.Length, buffer.Length);
}
buffer.Rewind();
deserializer = new Deserializer(buffer);
retrieved = deserializer.Create();
retrieved.Deserialize(deserializer);
var event12 = retrieved as SampleEvent5;
Assert.NotNull(event12);
Assert.AreEqual(event1.SampleCell.Foo, event12.SampleCell.Foo);
Assert.AreEqual(event1.SampleCell.Bar, event12.SampleCell.Bar);
}
