public void Serialize()
{
var person = new Person("first");
var person2 = new Person("second");
list.Add(person);
server.DequeueAndAssertMessage <BuddyListMessage>();
list.Add(person2);
server.DequeueAndAssertMessage <BuddyListMessage>();
var writer = new BufferValueWriter(new byte[1024]);
list.Serialize(clientContext, writer);
server.AssertNoMessage();
var reader = new BufferValueReader(writer.Buffer);
list.Deserialize(clientContext, reader);
Assert.AreEqual(writer.Length, reader.Position);
server.AssertNoMessage();
CollectionAssert.Contains(list, person);
CollectionAssert.Contains(list, person2);
}
public void ISerializable()
{
byte[] buffer = new byte[20480];
var writer = new BufferValueWriter(buffer);
SerializableTester tester = new SerializableTester
{
Name = "MONKEY!",
Numbers = new[] { 1, 2, 4, 8, 16, 32 }
};
var test = new AsyncTest();
tester.SerializeCalled += test.PassHandler;
writer.Write(context, tester);
writer.Flush();
var reader = new BufferValueReader(buffer);
var serialized = SerializerExtensions.Read <SerializableTester> (reader, context);
Assert.IsNotNull(serialized);
Assert.AreEqual(tester.Name, serialized.Name);
Assert.IsTrue(tester.Numbers.SequenceEqual(serialized.Numbers), "Numbers does not match");
test.Assert(1000);
}
public void Serialization()
{
var dict = new Dictionary <Type, ushort> {
{ typeof(string), 0 }, { typeof(int), 1 }
};
TypeMap map = new TypeMap(dict);
byte[] buffer = new byte[20480];
var writer = new BufferValueWriter(buffer);
map.Serialize(null, writer);
writer.Flush();
var reader = new BufferValueReader(buffer);
map = new TypeMap();
map.Deserialize(null, reader);
Type type;
Assert.IsTrue(map.TryGetType(0, out type));
Assert.AreEqual(typeof(string), type);
Assert.IsTrue(map.TryGetType(1, out type));
Assert.AreEqual(typeof(int), type);
ushort id;
Assert.IsFalse(map.GetTypeId(typeof(string), out id));
Assert.AreEqual(0, id);
Assert.IsFalse(map.GetTypeId(typeof(int), out id));
Assert.AreEqual(1, id);
}
protected override void SignMessage(Message message, string hashAlg, BufferValueWriter writer)
{
if (HMAC == null)
writer.WriteBytes (this.connection.LocalCrypto.HashAndSign (hashAlg, writer.Buffer, 0, writer.Length));
else
base.SignMessage (message, hashAlg, writer);
}
public void Serialize()
{
var crypto = new RSACryptoServiceProvider();
var p = new RSAAsymmetricKey(crypto.ExportCspBlob(true));
byte[] buffer = new byte[20480];
var writer = new BufferValueWriter(buffer);
p.Serialize(null, writer);
int len = writer.Length;
writer.Flush();
var reader = new BufferValueReader(buffer);
var key = new RSAAsymmetricKey(null, reader);
Assert.AreEqual(len, reader.Position);
Assert.IsNull(key.D);
Assert.IsNull(key.DP);
Assert.IsNull(key.DQ);
AssertArrayMatches(p.Exponent, key.Exponent);
Assert.IsNull(key.InverseQ);
AssertArrayMatches(p.Modulus, key.Modulus);
Assert.IsNull(key.P);
Assert.IsNull(key.Q);
Assert.IsNotNull(key.PublicSignature);
}
protected virtual void SignMessage(Message message, string hashAlg, BufferValueWriter writer)
{
if (HMAC == null)
{
throw new InvalidOperationException();
}
string callCategory = null;
#if TRACE
int c = GetNextCallId();
callCategory = String.Format("{0} {1}:SignMessage ({2},{3})", this.connectionType, c, hashAlg, writer.Length);
#endif
Trace.WriteLineIf(NTrace.TraceVerbose, "Entering", callCategory);
byte[] hash;
lock (HMAC)
hash = HMAC.ComputeHash(writer.Buffer, 0, writer.Length);
//Trace.WriteLineIf (NTrace.TraceVerbose, "Got hash: " + GetHex (hash), callCategory);
writer.WriteBytes(hash);
Trace.WriteLineIf(NTrace.TraceVerbose, "Exiting", callCategory);
}
public void ISerializable()
{
byte[] buffer = new byte[20480];
var writer = new BufferValueWriter (buffer);
SerializableTester tester = new SerializableTester
{
Name = "MONKEY!",
Numbers = new[] { 1, 2, 4, 8, 16, 32 }
};
var test = new AsyncTest();
tester.SerializeCalled += test.PassHandler;
writer.Write (context, tester);
writer.Flush();
var reader = new BufferValueReader (buffer);
var serialized = SerializerExtensions.Read<SerializableTester> (reader, context);
Assert.IsNotNull (serialized);
Assert.AreEqual (tester.Name, serialized.Name);
Assert.IsTrue (tester.Numbers.SequenceEqual (serialized.Numbers), "Numbers does not match");
test.Assert (1000);
}
public void BufferOverflowResize()
{
byte[] buffer = new byte[4];
var writer = new BufferValueWriter (buffer);
writer.WriteInt64 (1);
Assert.That (writer.Length, Is.EqualTo (8));
Assert.That (writer.Buffer.Length, Is.AtLeast (8));
}
public static byte[] GetBytes (this MessageBase messageBase)
{
var writer = new BufferValueWriter(new byte[1024]);
messageBase.WritePayload(writer);
var resizedBuffer = new byte[writer.Length];
Buffer.BlockCopy(writer.Buffer, 0, resizedBuffer, 0, resizedBuffer.Length);
return resizedBuffer;
}
public void BufferOverflowResize()
{
byte[] buffer = new byte[4];
var writer = new BufferValueWriter(buffer);
writer.WriteInt64(1);
Assert.That(writer.Length, Is.EqualTo(8));
Assert.That(writer.Buffer.Length, Is.AtLeast(8));
}
protected override void SignMessage(Message message, string hashAlg, BufferValueWriter writer)
{
if (message is FinalConnectMessage)
{
writer.WriteBytes(this.connection.LocalCrypto.HashAndSign(hashAlg, writer.Buffer, 0, writer.Length));
}
else
{
base.SignMessage(message, hashAlg, writer);
}
}
public static byte[] GetBytes(this MessageBase messageBase)
{
var writer = new BufferValueWriter(new byte[1024]);
messageBase.WritePayload(writer);
var resizedBuffer = new byte[writer.Length];
Buffer.BlockCopy(writer.Buffer, 0, resizedBuffer, 0, resizedBuffer.Length);
return(resizedBuffer);
}
public void Enum()
{
byte[] buffer = new byte[1024];
var writer = new BufferValueWriter (buffer);
writer.Write (context, TestEnum.High);
int len = writer.Length;
writer.Flush();
var reader = new BufferValueReader (buffer);
Assert.AreEqual (TestEnum.High, reader.Read<TestEnum> (context));
Assert.AreEqual (len, reader.Position);
}
public void ReadWriteLongSet()
{
var writer = new BufferValueWriter (new byte[1]);
for (int i = 0; i < 20480; ++i)
writer.WriteInt32(i);
writer.Flush();
var reader = new BufferValueReader (writer.Buffer);
for (int i = 0; i < 20480; ++i)
Assert.AreEqual(i, reader.ReadInt32());
}
public void ReadWriteUniversalDate()
{
byte[] buffer = new byte[20480];
var writer = new BufferValueWriter (buffer);
DateTime d = DateTime.Now;
writer.WriteUniversalDate (d);
writer.Flush();
var reader = new BufferValueReader (buffer);
Assert.AreEqual (d.ToUniversalTime(), reader.ReadUniversalDate());
}
public void ReadWriteUniversalDate()
{
byte[] buffer = new byte[20480];
var writer = new BufferValueWriter(buffer);
DateTime d = DateTime.Now;
writer.WriteUniversalDate(d);
writer.Flush();
var reader = new BufferValueReader(buffer);
Assert.AreEqual(d.ToUniversalTime(), reader.ReadUniversalDate());
}
public void Enum()
{
byte[] buffer = new byte[1024];
var writer = new BufferValueWriter(buffer);
writer.Write(context, TestEnum.High);
int len = writer.Length;
writer.Flush();
var reader = new BufferValueReader(buffer);
Assert.AreEqual(TestEnum.High, reader.Read <TestEnum> (context));
Assert.AreEqual(len, reader.Position);
}
public void ReadWrite7BitInt()
{
var writer = new BufferValueWriter(new byte[20480]);
writer.Write7BitEncodedInt(Int32.MinValue);
writer.Write7BitEncodedInt(0);
writer.Write7BitEncodedInt(Int32.MaxValue);
writer.Flush();
var reader = new BufferValueReader(writer.Buffer);
Assert.AreEqual(Int32.MinValue, reader.Read7BitEncodedInt());
Assert.AreEqual(0, reader.Read7BitEncodedInt());
Assert.AreEqual(Int32.MaxValue, reader.Read7BitEncodedInt());
}
public void ReadWrite7BitInt()
{
var writer = new BufferValueWriter (new byte[20480]);
writer.Write7BitEncodedInt (Int32.MinValue);
writer.Write7BitEncodedInt (0);
writer.Write7BitEncodedInt (Int32.MaxValue);
writer.Flush();
var reader = new BufferValueReader (writer.Buffer);
Assert.AreEqual (Int32.MinValue, reader.Read7BitEncodedInt());
Assert.AreEqual (0, reader.Read7BitEncodedInt());
Assert.AreEqual (Int32.MaxValue, reader.Read7BitEncodedInt());
}
public void Serializer()
{
byte[] buffer = new byte[1024];
var writer = new BufferValueWriter(buffer);
var c = SerializationContextTests.GetContext(MockProtocol.Instance);
var p = new Protocol(42, 248);
p.Serialize(c, writer);
writer.Flush();
var reader = new BufferValueReader(buffer);
var p2 = new Protocol(c, reader);
Assert.AreEqual(p.id, p2.id);
Assert.AreEqual(p.Version, p2.Version);
}
public void ReadWriteLongSet()
{
var writer = new BufferValueWriter(new byte[1]);
for (int i = 0; i < 20480; ++i)
{
writer.WriteInt32(i);
}
writer.Flush();
var reader = new BufferValueReader(writer.Buffer);
for (int i = 0; i < 20480; ++i)
{
Assert.AreEqual(i, reader.ReadInt32());
}
}
public void Serialize()
{
var person = new Person ("foobar") {
Nickname = "MyNickname",
Avatar = "MyAvatar",
Status = Status.Away
};
byte[] buffer = new byte[2048];
var bufferWriter = new BufferValueWriter (buffer);
person.Serialize (null, bufferWriter);
var bufferReader = new BufferValueReader (buffer);
var person2 = new Person (null, bufferReader);
Assert.AreEqual (person.Identity, person2.Identity);
Assert.AreEqual (person.Nickname, person2.Nickname);
Assert.AreEqual (person.Avatar, person2.Avatar);
Assert.AreEqual (person.Status, person2.Status);
}
public void Serialize()
{
var person = new Person("foobar")
{
Nickname = "MyNickname",
Avatar = "MyAvatar",
Status = Status.Away
};
byte[] buffer = new byte[2048];
var bufferWriter = new BufferValueWriter(buffer);
person.Serialize(null, bufferWriter);
var bufferReader = new BufferValueReader(buffer);
var person2 = new Person(null, bufferReader);
Assert.AreEqual(person.Identity, person2.Identity);
Assert.AreEqual(person.Nickname, person2.Nickname);
Assert.AreEqual(person.Avatar, person2.Avatar);
Assert.AreEqual(person.Status, person2.Status);
}
protected void EncryptMessage(BufferValueWriter writer, ref int headerLength)
{
AesManaged am = AES;
if (am == null)
{
return;
}
ICryptoTransform encryptor = null;
byte[] iv = null;
lock (am)
{
am.GenerateIV();
iv = am.IV;
encryptor = am.CreateEncryptor();
}
const int workingHeaderLength = LengthOffset + sizeof(int); // right after length
int r = ((writer.Length - workingHeaderLength) % encryptor.OutputBlockSize);
if (r != 0)
{
writer.Pad(encryptor.OutputBlockSize - r);
}
byte[] payload = encryptor.TransformFinalBlock(writer.Buffer, workingHeaderLength, writer.Length - workingHeaderLength);
writer.Length = workingHeaderLength;
writer.InsertBytes(workingHeaderLength, BitConverter.GetBytes(iv.Length), 0, sizeof(int));
writer.InsertBytes(workingHeaderLength + sizeof(int), iv, 0, iv.Length);
writer.WriteInt32(payload.Length);
writer.InsertBytes(writer.Length, payload, 0, payload.Length);
headerLength += iv.Length + sizeof(int);
}
// [Test] Testing core APIs that now have NETFX_CORE turned on everywhere
public void Serializable()
{
var inner = new Exception("Inner exception");
var ex = new InvalidOperationException("Don't do this, fool.", inner);
byte[] buffer = new byte[20480];
var writer = new BufferValueWriter(buffer);
writer.Write(context, ex);
writer.Flush();
var reader = new BufferValueReader(buffer);
InvalidOperationException ioex = SerializerExtensions.Read <InvalidOperationException> (reader, context);
Assert.IsNotNull(ioex);
Assert.AreEqual(ex.Message, ioex.Message);
Assert.AreEqual(ex.StackTrace, ioex.StackTrace);
Assert.IsNotNull(ioex.InnerException);
Assert.AreEqual(inner.Message, ioex.InnerException.Message);
Assert.AreEqual(inner.StackTrace, ioex.InnerException.StackTrace);
}
internal void Receive(MessageEventArgs e)
{
var context = new SerializationContext();
var writer = new BufferValueWriter(new byte[1024]);
e.Message.WritePayload(context, writer);
var reader = new BufferValueReader(writer.Buffer);
var message = e.Message.Protocol.Create(e.Message.MessageType);
message.ReadPayload(context, reader);
message.Header = e.Message.Header;
var tmessage = (e.Message as TempestMessage);
if (tmessage == null)
{
OnMessageReceived(new MessageEventArgs(e.Connection, message));
}
else
{
OnTempestMessageReceived(new MessageEventArgs(e.Connection, message));
}
}
public unsafe byte[] GetBytes(Message message, out int length, byte[] buffer)
#endif
{
string callCategory = null;
#if TRACE
int c = GetNextCallId();
callCategory = String.Format("{0} {1}:GetBytes({2},{3})", this.connectionType, c, message, buffer.Length);
#endif
Trace.WriteLineIf(NTrace.TraceVerbose, "Entering", callCategory);
int messageId = message.Header.MessageId;
if (message.Header.IsResponse)
{
messageId |= ResponseFlag;
}
BufferValueWriter writer = new BufferValueWriter(buffer);
writer.EnsureAdditionalCapacity(15);
int cid = (connection != null) ? connection.ConnectionId : 0;
int headerLength = BaseHeaderLength;
#if SAFE
writer.WriteByte(message.Protocol.id);
writer.WriteInt32(cid); // TODO: Change to variable length later
writer.WriteUInt16(message.MessageType);
writer.Length += sizeof(int); // length placeholder
writer.WriteInt32(messageId);
if (message.Header.IsResponse)
{
writer.WriteInt32(message.Header.ResponseMessageId);
headerLength += sizeof(int);
}
#else
fixed(byte *bptr = writer.Buffer)
{
*bptr = message.Protocol.id;
*((int *)(bptr + 1)) = cid;
*((ushort *)(bptr + 5)) = message.MessageType;
*((int *)(bptr + 11)) = messageId;
if (message.Header.IsResponse)
{
*((int *)(bptr + 15)) = message.Header.ResponseMessageId;
headerLength += sizeof(int);
}
}
writer.Extend(headerLength);
#endif
if (this.serializationContext == null)
{
if (this.connection != null)
{
this.serializationContext = new SerializationContext(this.connection, this.protocols);
}
else
{
this.serializationContext = new SerializationContext(this.protocols);
}
}
message.WritePayload(this.serializationContext, writer);
if (message.Encrypted)
{
EncryptMessage(writer, ref headerLength);
}
else if (message.Authenticated)
{
#if SAFE
for (int i = LengthOffset; i < LengthOffset + sizeof(int); ++i)
{
writer.Buffer[i] = 0;
}
#else
fixed(byte *mptr = writer.Buffer)
* ((int *)(mptr + LengthOffset)) = 0;
#endif
SignMessage(message, this.signingHashAlgorithm, writer);
}
byte[] rawMessage = writer.Buffer;
length = writer.Length;
#if SAFE
Buffer.BlockCopy(BitConverter.GetBytes(length), 0, rawMessage, LengthOffset, sizeof(int));
#else
fixed(byte *mptr = rawMessage)
* ((int *)(mptr + LengthOffset)) = length;
#endif
Trace.WriteLineIf(NTrace.TraceVerbose, String.Format("Exiting. Length: {0}", length), callCategory);
return(rawMessage);
}
protected override void OnTempestMessage (MessageEventArgs e)
{
switch (e.Message.MessageType)
{
case (ushort)TempestMessageType.AcknowledgeConnect:
{
var msg = (AcknowledgeConnectMessage)e.Message;
this.serializer.Protocols = this.serializer.Protocols.Intersect (msg.EnabledProtocols);
ConnectionId = msg.ConnectionId;
this.remoteEncryption = new RSACrypto();
this.remoteEncryption.ImportKey (msg.PublicEncryptionKey);
var encryption = new AesManaged { KeySize = 256 };
encryption.GenerateKey();
BufferValueWriter authKeyWriter = new BufferValueWriter (new byte[1600]);
LocalKey.Serialize (authKeyWriter, this.remoteEncryption);
SendAsync (new FinalConnectMessage
{
AESKey = this.remoteEncryption.Encrypt (encryption.Key),
PublicAuthenticationKeyType = LocalKey.GetType(),
PublicAuthenticationKey = authKeyWriter.ToArray()
});
this.serializer.AES = encryption;
this.serializer.HMAC = new HMACSHA256 (encryption.Key);
break;
}
case (ushort)TempestMessageType.Connected:
{
var msg = (ConnectedMessage)e.Message;
ConnectionId = msg.ConnectionId;
this.formallyConnected = true;
Timer t = Interlocked.Exchange (ref this.connectTimer, null);
if (t != null)
t.Dispose();
var tcs = Interlocked.Exchange (ref this.connectTcs, null);
if (tcs != null)
{
if (tcs.TrySetResult (new ClientConnectionResult (ConnectionResult.Success, RemoteKey)))
OnConnected();
}
break;
}
default:
base.OnTempestMessage (e);
break;
}
}
protected override IValueReader GetReader(IValueWriter writer)
{
BufferValueWriter bufferWriter = (BufferValueWriter)writer;
return(new BufferValueReader(bufferWriter.Buffer));
}
protected override void OnTempestMessageReceived(MessageEventArgs e)
{
switch (e.Message.MessageType)
{
case (ushort)TempestMessageType.Ping:
var ping = (PingMessage)e.Message;
if (PingFrequency == 0 || this.activityTimer == null)
{
if (this.activityTimer != null)
{
this.activityTimer.Dispose();
}
if (ping.Interval != 0)
{
this.activityTimer = new Tempest.Timer(100);
this.activityTimer.TimesUp += OnActivityTimer;
this.activityTimer.Start();
}
}
else if (ping.Interval != PingFrequency)
{
this.activityTimer.Interval = ping.Interval;
}
base.OnTempestMessageReceived(e);
break;
case (ushort)TempestMessageType.AcknowledgeConnect:
var msg = (AcknowledgeConnectMessage)e.Message;
this.protocols = this.protocols.Values.Intersect(msg.EnabledProtocols).ToDictionary(pr => pr.id);
ConnectionId = msg.ConnectionId;
this.serverEncryption = new RSACrypto();
this.serverEncryption.ImportKey((RSAAsymmetricKey)msg.PublicEncryptionKey);
this.serverEncryptionKey = (RSAAsymmetricKey)msg.PublicEncryptionKey;
var encryption = new AesManaged {
KeySize = 256
};
encryption.GenerateKey();
BufferValueWriter authKeyWriter = new BufferValueWriter(new byte[1600]);
this.publicAuthenticationKey.Serialize(this.serializer.SerializationContext, authKeyWriter, this.serverEncryption);
this.serializer.AES = encryption;
this.serializer.HMAC = new HMACSHA256(encryption.Key);
SendAsync(new FinalConnectMessage
{
AESKey = this.serverEncryption.Encrypt(encryption.Key),
PublicAuthenticationKeyType = this.publicAuthenticationKey.GetType(),
PublicAuthenticationKey = authKeyWriter.ToArray()
});
break;
case (ushort)TempestMessageType.Connected:
var connected = (ConnectedMessage)e.Message;
ConnectionId = connected.ConnectionId;
OnConnected(new ClientConnectionEventArgs(this));
var tcs = Interlocked.Exchange(ref this.connectCompletion, null);
if (tcs != null)
{
tcs.SetResult(new ClientConnectionResult(ConnectionResult.Success, this.serverAuthenticationKey));
}
break;
default:
base.OnTempestMessageReceived(e);
break;
}
}
public void Serialization()
{
var dict = new Dictionary<Type, ushort> { { typeof (string), 0 }, { typeof (int), 1 } };
TypeMap map = new TypeMap (dict);
byte[] buffer = new byte[20480];
var writer = new BufferValueWriter (buffer);
map.Serialize (null, writer);
writer.Flush();
var reader = new BufferValueReader (buffer);
map = new TypeMap();
map.Deserialize (null, reader);
Type type;
Assert.IsTrue (map.TryGetType (0, out type));
Assert.AreEqual (typeof (string), type);
Assert.IsTrue (map.TryGetType (1, out type));
Assert.AreEqual (typeof (int), type);
ushort id;
Assert.IsFalse (map.GetTypeId (typeof (string), out id));
Assert.AreEqual (0, id);
Assert.IsFalse (map.GetTypeId (typeof (int), out id));
Assert.AreEqual (1, id);
}
public void BufferWriterOverflow()
{
byte[] buffer = new byte[4];
var writer = new BufferValueWriter (buffer, false);
Assert.Throws<InternalBufferOverflowException> (() => writer.WriteInt64 (1));
}
protected override void SignMessage(string hashAlg, BufferValueWriter writer)
{
if (this.hmac == null)
writer.WriteBytes (this.provider.authentication.HashAndSign (hashAlg, writer.Buffer, 0, writer.Length));
else
base.SignMessage (hashAlg, writer);
}
protected override void OnTempestMessage(MessageEventArgs e)
{
switch (e.Message.MessageType)
{
case (ushort)TempestMessageType.AcknowledgeConnect:
{
var msg = (AcknowledgeConnectMessage)e.Message;
this.serializer.Protocols = this.serializer.Protocols.Intersect(msg.EnabledProtocols);
ConnectionId = msg.ConnectionId;
this.remoteEncryption = new RSACrypto();
this.remoteEncryption.ImportKey((RSAAsymmetricKey)msg.PublicEncryptionKey);
var encryption = new AesManaged {
KeySize = 256
};
encryption.GenerateKey();
BufferValueWriter authKeyWriter = new BufferValueWriter(new byte[1600]);
LocalKey.Serialize(this.serializer.SerializationContext, authKeyWriter, this.remoteEncryption);
SendAsync(new FinalConnectMessage
{
AESKey = this.remoteEncryption.Encrypt(encryption.Key),
PublicAuthenticationKeyType = LocalKey.GetType(),
PublicAuthenticationKey = authKeyWriter.ToArray()
});
this.serializer.AES = encryption;
this.serializer.HMAC = new HMACSHA256(encryption.Key);
break;
}
case (ushort)TempestMessageType.Connected:
{
var msg = (ConnectedMessage)e.Message;
ConnectionId = msg.ConnectionId;
this.formallyConnected = true;
Timer t = Interlocked.Exchange(ref this.connectTimer, null);
if (t != null)
{
t.Dispose();
}
var tcs = Interlocked.Exchange(ref this.connectTcs, null);
if (tcs != null)
{
if (tcs.TrySetResult(new ClientConnectionResult(ConnectionResult.Success, RemoteKey)))
{
OnConnected();
}
}
break;
}
default:
base.OnTempestMessage(e);
break;
}
}
public void Contracted()
{
byte[] buffer = new byte[20480];
var writer = new BufferValueWriter (buffer);
ISerializableTester test = new SerializableTester
{
Name = "MONKEY!",
Numbers = new[] { 1, 2, 4, 8, 16, 32 }
};
writer.Write (context, test);
writer.Flush();
var reader = new BufferValueReader (buffer);
var serialized = SerializerExtensions.Read<ISerializableTester> (reader, context);
Assert.IsNotNull (serialized);
Assert.AreEqual (test.Name, serialized.Name);
Assert.IsTrue (test.Numbers.SequenceEqual (serialized.Numbers), "Numbers does not match");
}
public void Serializer()
{
byte[] buffer = new byte[1024];
var writer = new BufferValueWriter (buffer);
var c = SerializationContextTests.GetContext (MockProtocol.Instance);
var p = new Protocol (42, 248);
p.Serialize (c, writer);
writer.Flush();
var reader = new BufferValueReader (buffer);
var p2 = new Protocol (c, reader);
Assert.AreEqual (p.id, p2.id);
Assert.AreEqual (p.Version, p2.Version);
}
protected override void OnTempestMessageReceived(MessageEventArgs e)
{
switch (e.Message.MessageType)
{
case (ushort)TempestMessageType.Ping:
var ping = (PingMessage)e.Message;
if (PingFrequency == 0 || this.activityTimer == null)
{
if (this.activityTimer != null)
this.activityTimer.Dispose();
if (ping.Interval != 0)
{
this.activityTimer = new Tempest.Timer (100);
this.activityTimer.TimesUp += OnActivityTimer;
this.activityTimer.Start();
}
}
else if (ping.Interval != PingFrequency)
this.activityTimer.Interval = ping.Interval;
base.OnTempestMessageReceived (e);
break;
case (ushort)TempestMessageType.AcknowledgeConnect:
var msg = (AcknowledgeConnectMessage)e.Message;
this.protocols = this.protocols.Values.Intersect (msg.EnabledProtocols).ToDictionary (pr => pr.id);
ConnectionId = msg.ConnectionId;
this.serverEncryption = new RSACrypto();
this.serverEncryption.ImportKey (msg.PublicEncryptionKey);
this.serverEncryptionKey = msg.PublicEncryptionKey;
var encryption = new AesManaged { KeySize = 256 };
encryption.GenerateKey();
BufferValueWriter authKeyWriter = new BufferValueWriter (new byte[1600]);
this.publicAuthenticationKey.Serialize (authKeyWriter, this.serverEncryption);
this.serializer.AES = encryption;
this.serializer.HMAC = new HMACSHA256 (encryption.Key);
SendAsync (new FinalConnectMessage
{
AESKey = this.serverEncryption.Encrypt (encryption.Key),
PublicAuthenticationKeyType = this.publicAuthenticationKey.GetType(),
PublicAuthenticationKey = authKeyWriter.ToArray()
});
break;
case (ushort)TempestMessageType.Connected:
var connected = (ConnectedMessage) e.Message;
ConnectionId = connected.ConnectionId;
OnConnected (new ClientConnectionEventArgs (this));
var tcs = Interlocked.Exchange (ref this.connectCompletion, null);
if (tcs != null)
tcs.TrySetResult (new ClientConnectionResult (ConnectionResult.Success, this.serverAuthenticationKey));
break;
default:
base.OnTempestMessageReceived(e);
break;
}
}
public void PrimitiveAsObject()
{
byte[] buffer = new byte[1024];
var writer = new BufferValueWriter (buffer);
writer.Write (context, (object)20f);
writer.Flush();
var reader = new BufferValueReader (buffer);
object value = SerializerExtensions.Read<object> (reader, context);
Assert.IsNotNull (value);
Assert.AreEqual (20f, value);
}
// [Test] Testing core APIs that now have NETFX_CORE turned on everywhere
public void Serializable()
{
var inner = new Exception ("Inner exception");
var ex = new InvalidOperationException ("Don't do this, fool.", inner);
byte[] buffer = new byte[20480];
var writer = new BufferValueWriter (buffer);
writer.Write (context, ex);
writer.Flush();
var reader = new BufferValueReader (buffer);
InvalidOperationException ioex = SerializerExtensions.Read<InvalidOperationException> (reader, context);
Assert.IsNotNull (ioex);
Assert.AreEqual (ex.Message, ioex.Message);
Assert.AreEqual (ex.StackTrace, ioex.StackTrace);
Assert.IsNotNull (ioex.InnerException);
Assert.AreEqual (inner.Message, ioex.InnerException.Message);
Assert.AreEqual (inner.StackTrace, ioex.InnerException.StackTrace);
}
public void SerializableTypeContainingNonSerializableField()
{
byte[] buffer = new byte[20480];
var writer = new BufferValueWriter (buffer);
ObjectSerializer serializer = ObjectSerializer.GetSerializer (typeof (SerializableWithNonSerializableField));
var test = new SerializableWithNonSerializableField (2, 3, "hi");
serializer.Serialize (context, writer, test);
writer.Flush();
var reader = new BufferValueReader (buffer);
var serialized = (SerializableWithNonSerializableField)serializer.Deserialize (context, reader);
Assert.AreEqual (2, serialized.X);
Assert.AreEqual (3, serialized.Y);
Assert.AreEqual ("hi", serialized.Content);
}
public void ValueReaderCtor()
{
byte[] buffer = new byte[20480];
var writer = new BufferValueWriter (buffer);
ValueReaderTester test = new ValueReaderTester ("TheName");
writer.Write (context, test);
writer.Flush();
var reader = new BufferValueReader (buffer);
var serialized = SerializerExtensions.Read<ValueReaderTester> (reader, context);
Assert.AreEqual (test.Name, serialized.Name);
}
public void Serialize()
{
var person = new Person ("first");
var person2 = new Person ("second");
list.Add (person);
server.DequeueAndAssertMessage<BuddyListMessage>();
list.Add (person2);
server.DequeueAndAssertMessage<BuddyListMessage>();
var writer = new BufferValueWriter (new byte[1024]);
list.Serialize (clientContext, writer);
server.AssertNoMessage();
var reader = new BufferValueReader (writer.Buffer);
list.Deserialize (clientContext, reader);
Assert.AreEqual (writer.Length, reader.Position);
server.AssertNoMessage();
CollectionAssert.Contains (list, person);
CollectionAssert.Contains (list, person2);
}
