public void SendActorMessageToServiceBusTopic()
{
string TopicName = "test-" + "SendActorMessageToServiceBusTopic".ToLower();
// we cannot send messages to topics that have no subscriptions in them
var proc = this.StartProcessing(TopicName, "test");
try
{
string message = "HelloWorld";
PingPong.Ping aMsg = new PingPong.Ping(message);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
Telegraph.Instance.Register <PingPong.Ping, SendMessageToServiceBusTopic <PingPong.Ping> >(() => new SendMessageToServiceBusTopic <PingPong.Ping>(Connections.ServiceBusConnectionString, TopicName, true));
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(() => serializer);
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
deserializer.Register <PingPong.Ping>((object msg) => (PingPong.Ping)msg);
if (!Telegraph.Instance.Ask(aMsg).Wait(new TimeSpan(0, 0, 10)))
{
Assert.Fail("Waited too long to send a message");
}
ServiceBusReceivedMessage sbMessage = null;
WaitForQueue(sbMsgQueue, out sbMessage);
DeserializeMessage <IActorMessage> dMsg = new DeserializeMessage <IActorMessage>(sbMessage.Body.ToArray());
deserializer.Ask(dMsg);
var retMsgs = (PingPong.Ping)dMsg.ProcessingResult;
Assert.IsTrue(((string)retMsgs.Message).Equals(message));
}
finally
{
proc.StopProcessingAsync().Wait();
Telegraph.Instance.UnRegisterAll();
DeleteServiceBusTopic(TopicName);
}
}
public void SendActorMessageToStorageQueue()
{
string queueName = "test-" + "SendActorMessageToStorageQueue".ToLower();
var queue = GetStorageQueue(queueName);
try
{
string message = "HelloWorld";
PingPong.Ping aMsg = new PingPong.Ping(message);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
Telegraph.Instance.Register <PingPong.Ping, SendMessageToStorageQueue <PingPong.Ping> >(() => new SendMessageToStorageQueue <PingPong.Ping>(Connections.StorageConnectionString, queueName, true));
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(() => serializer);
if (!Telegraph.Instance.Ask(aMsg).Wait(new TimeSpan(0, 10, 0)))
{
Assert.Fail("Waited too long to send a message");
}
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
deserializer.Register <PingPong.Ping>((object msg) => (PingPong.Ping)msg);
var base64String = queue.ReceiveMessage().Value.Body.ToString();
var messageBytes = Convert.FromBase64String(base64String);
DeserializeMessage <IActorMessage> dMsg = new DeserializeMessage <IActorMessage>(messageBytes);
deserializer.Ask(dMsg);
var retMsgs = (PingPong.Ping)dMsg.ProcessingResult;
Assert.IsTrue(((string)retMsgs.Message).Equals(message));
}
finally
{
Telegraph.Instance.UnRegisterAll();
GetStorageQueue(queueName).DeleteAsync();
GetStorageQueue(queueName + "-deadletter").DeleteAsync();
}
}
public void SendActorMessageToDirectoryQueue()
{
string queueName = "test-" + "SendActorMessageToStorageQueue".ToLower();
using (var queue = GetDirectoryQueue(queueName))
{
try
{
string message = "HelloWorld";
PingPong.Ping aMsg = new PingPong.Ping(message);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
var sendMessageQueue = new SendMessageToDirectoryQueue <PingPong.Ping>(queueRootPath, queueName, true);
Telegraph.Instance.Register <PingPong.Ping, SendMessageToDirectoryQueue <PingPong.Ping> >(() => sendMessageQueue);
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(() => serializer);
if (!Telegraph.Instance.Ask(aMsg).Wait(new TimeSpan(0, 0, 10)))
{
Assert.Fail("Waited too long to send a message");
}
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
deserializer.Register <PingPong.Ping>((object msg) => (PingPong.Ping)msg);
DeserializeMessage <IActorMessage> dMsg = new DeserializeMessage <IActorMessage>(queue.GetMessage().AsBytes);
deserializer.Ask(dMsg);
var retMsgs = (PingPong.Ping)dMsg.ProcessingResult;
Assert.IsTrue(((string)retMsgs.Message).Equals(message));
}
finally
{
Telegraph.Instance.UnRegisterAll();
queue.Delete();
GetDirectoryQueue(queueName + "-deadletter").Delete();
}
}
}
static void RecieveFromSpecificQueues(string queueAccountConnectionString, string queue1Name, string queue2Name)
{
long serializationOperator = Telegraph.Instance.Register(new LocalQueueOperator());
long operator1ID = Telegraph.Instance.Register(new StorageQueueSubscriptionOperator <IActorMessage>(LocalConcurrencyType.ActorsOnThreadPool, queueAccountConnectionString, queue1Name));
long operator2ID = Telegraph.Instance.Register(new StorageQueueSubscriptionOperator <IActorMessage>(LocalConcurrencyType.DedicatedThreadCount, queueAccountConnectionString, queue2Name, false, 3));
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
Telegraph.Instance.Register <DeserializeMessage <IActorMessage>, IActorMessageDeserializationActor>(serializationOperator, () => deserializer);
deserializer.Register <PingPong.Ping>((object msg) => (PingPong.Ping)msg);
deserializer.Register <PingPong.Pong>((object msg) => (PingPong.Pong)msg);
Telegraph.Instance.Register <PingPong.Pong>(operator2ID, pong =>
{
System.Threading.Thread.Sleep(100);
Console.WriteLine(pong.Message);
});
Telegraph.Instance.Register <PingPong.Ping>(operator1ID, ping =>
{
System.Threading.Thread.Sleep(100);
Console.WriteLine(ping.Message);
});
Telegraph.Instance.WaitTillEmpty(new TimeSpan(1, 0, 30));
}
public void SendActorMessageToEventHub()
{
string eventHubName = "test-" + "SendActorMessageToEventHub".ToLower();
string consumerGroup = eventHubName + Guid.NewGuid().ToString().Substring(0, 6);
CreateEventHub(eventHubName, consumerGroup);
try
{
string message = "HelloWorld";
PingPong.Ping aMsg = new PingPong.Ping(message);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
Telegraph.Instance.Register <PingPong.Ping, SendMessageToEventHub <PingPong.Ping> >(() => new SendMessageToEventHub <PingPong.Ping>(Connections.EventHubConnectionString, eventHubName, true));
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(() => serializer);
if (!Telegraph.Instance.Ask(aMsg).Wait(new TimeSpan(0, 0, 10)))
{
Assert.Fail("Waited too long to send a message");
}
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
deserializer.Register <PingPong.Ping>((object msg) => (PingPong.Ping)msg);
EventData ehMessage = null;
StartEventHubReciever(eventHubName, consumerGroup);
WaitForQueue(ehMsgQueue, out ehMessage);
DeserializeMessage <IActorMessage> dMsg = new DeserializeMessage <IActorMessage>(ehMessage.Body.ToArray());
deserializer.Ask(dMsg);
var retMsgs = (PingPong.Ping)dMsg.ProcessingResult;
Assert.IsTrue(((string)retMsgs.Message).Equals(message));
}
finally
{
Telegraph.Instance.UnRegisterAll();
DeleteEventHub(eventHubName);
}
}
public static void ComplexMessageSerializationDeserialization()
{
Telegraph.Instance.Register(new LocalQueueOperator(new LocalSwitchboard(LocalConcurrencyType.ActorsOnThreadPool))); // performs a reset.
IActorMessageDeserializationActor deserialization = new IActorMessageDeserializationActor();
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(() => new IActorMessageSerializationActor());
Telegraph.Instance.Register <DeserializeMessage <IActorMessage>, IActorMessageDeserializationActor>(() => deserialization);
deserialization.Register <CustomSerializableMessage>((object msg) => (CustomSerializableMessage)msg);
CustomSerializableMessage originalMsg = new CustomSerializableMessage(100, "Foo");
SerializeMessage <IActorMessage> serializeRqst = new SerializeMessage <IActorMessage>(originalMsg);
var serializeTask = Telegraph.Instance.Ask(serializeRqst);
serializeTask.Wait();
//NOTE you could also do the following to avoid having to register above
//var serializeTask = (new MessageSerializationActor()).Ask(serializeRqst);
//serializeTask.Wait();
byte[] serializedBytes = (serializeTask.Result.ProcessingResult as byte[]);
DeserializeMessage <IActorMessage> msgToDeSerialize = new DeserializeMessage <IActorMessage>(serializedBytes);
var task = Telegraph.Instance.Ask(msgToDeSerialize);
task.Wait();
CustomSerializableMessage output = (task.Result as CustomSerializableMessage);
Console.WriteLine("Serialized " + output.MyProperty.ToString());
System.Diagnostics.Debug.Assert(100 == output.MyProperty);
}
public void DeSerializeInDeserializeClass()
{
byte[] serializedBytes = SimpleMessageSerializationReturn();
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
DeserializeMessage <IActorMessage> deserializationMessage = new DeserializeMessage <IActorMessage>(serializedBytes);
if (!deserializer.OnMessageRecieved(deserializationMessage))
{
Assert.Fail("De-serialization Failed.");
}
Assert.IsTrue(deserializationMessage.Message.Equals("Foo"));
}
public void DeSerializeDeSerializeMessage()
{
byte[] serializedBytes = SimpleMessageSerializationReturn();
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
DeserializeMessage <IActorMessage> deserializationMessage = new DeserializeMessage <IActorMessage>(serializedBytes);
Telegraph.Instance.Register <DeserializeMessage <IActorMessage>, IActorMessageDeserializationActor>(() => new IActorMessageDeserializationActor());
DeserializeMessage <IActorMessage> msgToSerialize2 = new DeserializeMessage <IActorMessage>(serializedBytes);
var task = Telegraph.Instance.Ask(msgToSerialize2);
task.Wait();
string output = (task.Result.Message as string);
Assert.IsTrue(output.Equals("Foo"));
}
static void RecieveFromAzureServiceBusSubscription(string connectionString, string topicName, string subscription)
{
long localOperatorID = Telegraph.Instance.Register(new LocalQueueOperator());
long azureOperatorID = Telegraph.Instance.Register(new ServiceBusTopicSubscriptionOperator <IActorMessage>(LocalConcurrencyType.DedicatedThreadCount, connectionString, topicName, subscription, true));
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
Telegraph.Instance.Register <DeserializeMessage <IActorMessage>, IActorMessageDeserializationActor>(localOperatorID, () => deserializer);
deserializer.Register <PingPong.Ping>((object msg) => (PingPong.Ping)msg);
Telegraph.Instance.Register <PingPong.Ping>(azureOperatorID, pung =>
{
System.Threading.Thread.Sleep(100);
Console.WriteLine(subscription + ":" + pung.Message);
});
Telegraph.Instance.WaitTillEmpty(new TimeSpan(0, 0, 30));
Telegraph.Instance.Ask(new ControlMessages.HangUp()).Wait();
}
public void SimpleMessageDeSerialization()
{
Telegraph.Instance.UnRegisterAll();
Telegraph.Instance.Register(new LocalQueueOperator(new LocalSwitchboard(LocalConcurrencyType.ActorsOnThreadPool))); // performs a reset.
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
SimpleMessage <string> msgToSerialize = new SimpleMessage <string>();
msgToSerialize.Status = GetMessageCompletionMonitor();
msgToSerialize.Message = "Foo";
if (!serializer.OnMessageRecieved(msgToSerialize))
{
Console.Error.WriteLine("Serialization Failed.");
}
msgToSerialize.Status.Task.Wait();
byte[] serializedBytes = (msgToSerialize.Status.Task.Result.ProcessingResult as byte[]);
DeserializeMessage <IActorMessage> deserializationMessage = new DeserializeMessage <IActorMessage>(serializedBytes);
if (!deserializer.OnMessageRecieved(deserializationMessage))
{
Console.Error.WriteLine("De-serialization Failed.");
}
string deserilizedMessage = (deserializationMessage.Message as string);
msgToSerialize.ProcessingResult = null;
Telegraph.Instance.Register <DeserializeMessage <IActorMessage>, IActorMessageDeserializationActor>(() => new IActorMessageDeserializationActor());
DeserializeMessage <IActorMessage> msgToSerialize2 = new DeserializeMessage <IActorMessage>(serializedBytes);
var task = Telegraph.Instance.Ask(msgToSerialize2);
task.Wait();
string output = (task.Result.Message as string);
}
public void RecieveActorMessageFromDirectoryQueue()
{
string queueName = "test-" + "RecieveActorMessageFromStorageQueue".ToLower();
using (var queue = GetDirectoryQueue(queueName))
{
queue.CreateIfNotExists();
try
{
string message = "HelloWorld";
var actorMessage = new PingPong.Ping(message);
SerializeMessage <IActorMessage> sMsg = new SerializeMessage <IActorMessage>(actorMessage);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
serializer.OnMessageRecieved(sMsg);
byte[] msgBytes = (byte[])sMsg.ProcessingResult;
ManualResetEvent received = new ManualResetEvent(false);
IActorMessageDeserializationActor deserilaizationActor = new IActorMessageDeserializationActor();
Telegraph.Instance.Register <DeserializeMessage <IActorMessage> >(deserilaizationActor);
deserilaizationActor.Register((object msg) => (IActorMessage)msg);
deserilaizationActor.Register((object msg) => (PingPong.Ping)msg);
long azureOperatorID = Telegraph.Instance.Register(
new DirectoryQueueSubscriptionOperator <IActorMessage>(LocalConcurrencyType.DedicatedThreadCount, queueRootPath, queueName, false, 2),
(PingPong.Ping foo) =>
{
Assert.IsTrue(message.Equals((string)foo.Message, StringComparison.InvariantCulture));
received.Set();
});
queue.AddMessage(new DirectoryQueueMessage(msgBytes));
Assert.IsTrue(received.WaitOne(TimeSpan.FromSeconds(13), true), "We did not receive the message");
}
finally
{
Telegraph.Instance.UnRegisterAll();
GetDirectoryQueue(queueName).Delete();
GetDirectoryQueue(queueName + "-deadletter").Delete();
}
}
}
public void TestSendingActorMessageToHybridConnection()
{
string relayName = "TestSendingActorMessageToHybridConnection";
string sendMessage = "Hello";
var actorSendMessage = new PingPong.Ping(sendMessage);
var actorResponseMessage = new PingPong.Pong();
CreateHybridConnection(relayName);
Telegraph.Instance.Register(typeof(Exception), FailOnException);
HybridConnectionListener listener = null;
try
{
listener = CreateHybridListener(relayName, actorResponseMessage);
var relayConnection = new Telegraphy.Azure.Relay.Hybrid.RecieveResponseFromRequest <PingPong.Ping, PingPong.Pong>(Connections.HybridRelayConnectionString, relayName);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
deserializer.Register <PingPong.Pong>((object msg) => (PingPong.Pong)msg);
Telegraph.Instance.Register <SerializeMessage <PingPong.Ping>, IActorMessageSerializationActor>(() => serializer);
Telegraph.Instance.Register <DeserializeMessage <PingPong.Pong>, IActorMessageDeserializationActor>(() => deserializer);
Telegraph.Instance.Register <PingPong.Ping, Telegraphy.Azure.Relay.Hybrid.RecieveResponseFromRequest <PingPong.Ping, PingPong.Pong> >(() => relayConnection);
var resultTask = Telegraph.Instance.Ask(actorSendMessage);
bool success = resultTask.Wait(TimeSpan.FromSeconds(10));
Assert.IsTrue(success);
if (success)
{
Assert.IsTrue(resultTask.Result is PingPong.Pong);
}
}
finally
{
Telegraph.Instance.UnRegisterAll();
try { listener?.CloseAsync().Wait(); } catch (Exception) { }
DeleteRelay(relayName);
}
}
public void SendActorMessageToServiceBusQueueViaOperator()
{
string queueName = "test-" + "SendActorMessageToServiceBusQueueViaOperator".ToLower();
var proc = this.StartProcessing(queueName);
try
{
string message = "HelloWorld";
PingPong.Ping aMsg = new PingPong.Ping(message);
long localOperatorID = Telegraph.Instance.Register(new LocalQueueOperator(LocalConcurrencyType.DedicatedThreadCount, 2));
long azureOperatorId = Telegraph.Instance.Register(new ServiceBusQueuePublishOperator <IActorMessage>(Connections.ServiceBusConnectionString, queueName, true));
Telegraph.Instance.Register <PingPong.Ping>(azureOperatorId);
IActorMessageSerializationActor serializer = new IActorMessageSerializationActor();
Telegraph.Instance.Register <SerializeMessage <IActorMessage>, IActorMessageSerializationActor>(localOperatorID, () => serializer);
if (!Telegraph.Instance.Ask(aMsg).Wait(new TimeSpan(0, 0, 10)))
{
Assert.Fail("Waited too long to send a message");
}
IActorMessageDeserializationActor deserializer = new IActorMessageDeserializationActor();
deserializer.Register <PingPong.Ping>((object msg) => (PingPong.Ping)msg);
ServiceBusReceivedMessage sbMessage = null;
WaitForQueue(sbMsgQueue, out sbMessage);
DeserializeMessage <IActorMessage> dMsg = new DeserializeMessage <IActorMessage>(sbMessage.Body.ToArray());
deserializer.Ask(dMsg);
var retMsgs = (PingPong.Ping)dMsg.ProcessingResult;
Assert.IsTrue(((string)retMsgs.Message).Equals(message));
}
finally
{
proc.StopProcessingAsync().Wait();
Telegraph.Instance.UnRegisterAll();
DeleteServiceBusQueue(queueName);
}
}
private static void TestValTypeArray <T>(IActorMessageSerializationActor serialization, IActorMessageDeserializationActor deserialization, T[] val) where T : IEquatable <T>
{
ValueArrayTypeMessage <T> intType = new ValueArrayTypeMessage <T>(val);
var typeVal = (T[])intType.Message;
string id = intType.Id;
SerializeMessage <IActorMessage> sMsg = new SerializeMessage <IActorMessage>(intType);
if (!serialization.OnMessageRecieved(sMsg))
{
Assert.Fail(string.Format("Seriaization of array {0} Failed", val.GetType().Name));
}
DeserializeMessage <IActorMessage> dMsg = new DeserializeMessage <IActorMessage>(sMsg.ProcessingResult as byte[]);
if (!deserialization.OnMessageRecieved(dMsg))
{
Assert.Fail(string.Format("DeSeriaization of array {0} Failed", val.GetType().Name));
}
T[] message = (T[])(dMsg.ProcessingResult as ValueTypeMessage <T>).Message;
for (int i = 0; i < message.Length; ++i)
{
Assert.IsTrue(message[i].Equals(typeVal[i]));
}
Assert.IsTrue(message.Length != 0);
Assert.IsTrue((dMsg.ProcessingResult as IActorMessageIdentifier).Id.Equals(id));
}
public void SerializeAValueTypeMessage()
{
IActorMessageSerializationActor serialization = new IActorMessageSerializationActor();
IActorMessageDeserializationActor deserialization = new IActorMessageDeserializationActor();
deserialization.Register((object msg) => (ValueTypeMessage <int>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <int>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <double>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <double>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <float>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <float>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <byte>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <byte>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <sbyte>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <sbyte>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <short>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <short>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <ushort>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <ushort>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <uint>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <uint>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <double>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <double>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <long>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <long>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <ulong>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <ulong>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <bool>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <bool>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <decimal>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <decimal>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <char>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <char>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <DateTime>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <DateTime>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <TimeSpan>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <TimeSpan>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <Guid>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <Guid>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <DateTimeOffset>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <DateTimeOffset>)msg);
//deserialization.Register((object msg) => (ValueTypeMessage<ArraySegment<byte>>)msg);
deserialization.Register((object msg) => (ValueTypeMessage <TimeZoneInfo.TransitionTime>)msg);
deserialization.Register((object msg) => (ValueArrayTypeMessage <TimeZoneInfo.TransitionTime>)msg);
DateTime start = DateTime.Now;
DateTime utcStart = start.ToUniversalTime();
TestValType <int>(serialization, deserialization, 4);
TestValTypeArray <int>(serialization, deserialization, new int[] { 4, 3 });
TestValType <double>(serialization, deserialization, 4.2);
TestValTypeArray <double>(serialization, deserialization, new double[] { 4, 3 });
TestValType <float>(serialization, deserialization, 4.1F);
TestValTypeArray <float>(serialization, deserialization, new float[] { 4, 3 });
TestValType <byte>(serialization, deserialization, 8);
TestValTypeArray <byte>(serialization, deserialization, new byte[] { 4, 3 });
TestValType <sbyte>(serialization, deserialization, 2);
TestValTypeArray <sbyte>(serialization, deserialization, new sbyte[] { 4, 3 });
TestValType <short>(serialization, deserialization, 30);
TestValTypeArray <short>(serialization, deserialization, new short[] { 4, 3 });
TestValType <ushort>(serialization, deserialization, 200);
TestValTypeArray <ushort>(serialization, deserialization, new ushort[] { 4, 3 });
TestValType <uint>(serialization, deserialization, uint.MaxValue);
TestValTypeArray <uint>(serialization, deserialization, new uint[] { 4, 3 });
TestValType <long>(serialization, deserialization, long.MinValue);
TestValTypeArray <long>(serialization, deserialization, new long[] { 4, 3 });
TestValType <ulong>(serialization, deserialization, ulong.MaxValue);
TestValTypeArray <ulong>(serialization, deserialization, new ulong[] { 4, 3 });
TestValType <ulong>(serialization, deserialization, ulong.MinValue);
TestValTypeArray <ulong>(serialization, deserialization, new ulong[] { 4, 3 });
TestValType <bool>(serialization, deserialization, true);
TestValTypeArray <bool>(serialization, deserialization, new bool[] { true, false });
TestValType <bool>(serialization, deserialization, false);
TestValType <decimal>(serialization, deserialization, (decimal)5.67);
TestValTypeArray <decimal>(serialization, deserialization, new decimal[] { 4, 3 });
TestValType <char>(serialization, deserialization, 'a');
TestValTypeArray <char>(serialization, deserialization, new char[] { 'a', 'c' });
TestValType <DateTime>(serialization, deserialization, DateTime.Now);
TestValType <TimeSpan>(serialization, deserialization, DateTime.Now - start);
TestValType <Guid>(serialization, deserialization, Guid.NewGuid());
TestValTypeArray <Guid>(serialization, deserialization, new Guid[] { Guid.NewGuid(), Guid.NewGuid() });
TestValType <DateTimeOffset>(serialization, deserialization, new DateTimeOffset(start));
var myDt = DateTime.SpecifyKind(new DateTime(1, 1, 1), DateTimeKind.Unspecified);
TestValType <TimeZoneInfo.TransitionTime>(serialization, deserialization, TimeZoneInfo.TransitionTime.CreateFixedDateRule(myDt, 10, 11));
}
