public void AmqpCodecDescribedValueTest()
{
byte[] workBuffer = new byte[2048];
Action <object, object, byte[]> runTest = (d, v, b) =>
{
var dv = new DescribedValue(d, v);
ByteBuffer buffer;
AmqpSerializer.Serialize(buffer = new ByteBuffer(workBuffer, 0, 0, workBuffer.Length), dv);
var dv2 = AmqpSerializer.Deserialize <DescribedValue>(buffer);
Assert.AreEqual(dv.Descriptor, dv2.Descriptor);
if (dv.Value == null)
{
Assert.IsTrue(dv2.Value == null);
}
else if (dv.Value.GetType() == typeof(List))
{
EnsureEqual((IList)dv.Value, (IList)dv2.Value);
}
else
{
Assert.AreEqual(dv.Value, dv2.Value);
}
};
runTest(0, "uri", workBuffer);
runTest(long.MaxValue, (Symbol)"abcd", workBuffer);
runTest("descriptor", new List()
{
0, "x"
}, workBuffer);
runTest((Symbol)"null", null, workBuffer);
}
internal override void OnDisposition(uint first, uint last, DescribedValue deliveryState)
{
if (this.deliveryId >= first && this.deliveryId <= last)
{
this.deliveryState = deliveryState;
}
}
internal void SendDisposition(bool role, uint deliveryId, bool settled, DescribedValue state)
{
List disposition = new List()
{
role, deliveryId, null, settled, state
};
this.WriteFrame(0, 0, 0x15ul, disposition);
Fx.DebugPrint(true, 0, "disposition", disposition, "role", "first", "last");
}
public static bool Equals(DescribedValue <T> first, DescribedValue <T> second)
{
if (first == null && second == null)
{
return(true);
}
if (first == null && second != null)
{
return(false);
}
if (first != null && second == null)
{
return(false);
}
return(first.Descriptor.Equals(second.Descriptor) && first.Value.Equals(second.Value));
}
public void Send(Message message, int timeout)
{
Fx.AssertAndThrow(ErrorCode.SenderSendInvalidState, this.State < 0xff);
this.client.Wait(o => ((Sender)o).credit == 0, this, 60000);
lock (this)
{
if (this.credit < uint.MaxValue)
{
this.credit--;
}
}
this.deliveryState = null;
this.deliveryId = this.client.Send(this, message, timeout == 0);
this.deliveryCount++;
this.client.Wait(o => ((Sender)o).deliveryState == null, this, timeout);
if (!object.Equals(this.deliveryState.Descriptor, 0x24ul))
{
throw new Exception(this.deliveryState.Value.ToString());
}
}
public void AmqpSerializerMapEncodingTest()
{
// serializer test
{
var specification = new ComputerSpecification()
{
Cores = 2, RamSize = 4, Description = "netbook"
};
var product = new Product()
{
Name = "Computer", Price = 499.98, Weight = 30, Specification = specification, Category = Category.Electronic
};
var buffer = new ByteBuffer(1024, true);
AmqpSerializer.Serialize(buffer, product);
Assert.AreEqual(product.Properties["OnSerializing"], "true");
Assert.AreEqual(product.Properties["OnSerialized"], "true");
var product2 = AmqpSerializer.Deserialize <Product>(buffer);
Assert.AreEqual(product2.Properties["OnDeserializing"], "true");
Assert.AreEqual(product2.Properties["OnDeserialized"], "true");
Assert.AreEqual(product.Name, product2.Name);
Assert.AreEqual(product.Price, product2.Price);
Assert.AreEqual(product.Weight, product2.Weight);
Assert.AreEqual(product.Category, product2.Category);
var specification2 = product2.Specification as ComputerSpecification;
Assert.IsTrue(specification2 != null);
Assert.AreEqual(specification.Cores, specification2.Cores);
Assert.AreEqual(specification.RamSize, specification2.RamSize);
Assert.AreEqual(specification.Description, specification2.Description);
}
// serializer - amqp
{
var specification = new CarSpecification()
{
Engine = "V6", HorsePower = 239, Description = "SUV"
};
var product = new Product()
{
Name = "Car", Price = 34998, Weight = 5500, Specification = specification
};
var buffer = new ByteBuffer(1024, true);
AmqpSerializer.Serialize(buffer, product);
var value = Encoder.ReadObject(buffer) as DescribedValue;
Assert.IsTrue(value != null);
Assert.AreEqual(new Symbol("test.amqp:product"), value.Descriptor);
var map = value.Value as Map;
Assert.IsTrue(map != null);
Assert.AreEqual(product.Name, map[new Symbol("Name")]);
Assert.AreEqual(product.Price, map[new Symbol("Price")]);
Assert.AreEqual(product.Weight, map[new Symbol("Weight")]);
var specValue = map[new Symbol("Specification")] as DescribedValue;
Assert.IsTrue(specValue != null);
Assert.AreEqual(new Symbol("test.amqp:automotive-specification"), specValue.Descriptor);
var specMap = specValue.Value as Map;
Assert.IsTrue(specMap != null);
Assert.AreEqual(specification.Engine, specMap[new Symbol("Engine")]);
Assert.AreEqual(specification.HorsePower, specMap[new Symbol("HorsePower")]);
Assert.AreEqual(specification.Description, specMap[new Symbol("Description")]);
}
// amqp - serializer
{
// keys MUST be symbols
// the value types MUST match the field/property types in the class
var specification = new DescribedValue(
new Symbol("test.amqp:automotive-specification"),
new Map()
{
{ new Symbol("Engine"), "V8" },
{ new Symbol("HorsePower"), 222 },
{ new Symbol("Description"), "AWD SUV" },
});
var product = new DescribedValue(
new Symbol("test.amqp:product"),
new Map()
{
{ new Symbol("Name"), "Car" },
{ new Symbol("Price"), 41200.0 },
{ new Symbol("Weight"), 5600L },
{ new Symbol("Specification"), specification },
{ new Symbol("Category"), (sbyte)Category.Automotive }
});
var buffer = new ByteBuffer(1024, true);
Encoder.WriteObject(buffer, product);
var product2 = AmqpSerializer.Deserialize <Product>(buffer);
Assert.AreEqual("Car", product2.Name);
Assert.AreEqual(41200.0, product2.Price);
Assert.AreEqual(5600L, product2.Weight);
Assert.AreEqual(Category.Automotive, product2.Category);
var specification2 = product2.Specification as CarSpecification;
Assert.IsTrue(specification2 != null);
Assert.AreEqual("V8", specification2.Engine);
Assert.AreEqual(222, specification2.HorsePower);
Assert.AreEqual("AWD SUV", specification2.Description);
}
}
public void AmqpSerializerListEncodingTest()
{
Action <Person, Person> personValidator = (p1, p2) =>
{
Assert.IsTrue(p2 != null);
Assert.AreEqual(21, p2.Age, "Age should be increased by OnDeserialized");
Assert.AreEqual(p1.GetType().Name, p2.GetType().Name);
Assert.AreEqual(p1.DateOfBirth.Value, p2.DateOfBirth.Value);
Assert.AreEqual(p1.Properties.Count, p2.Properties.Count);
foreach (var k in p1.Properties.Keys)
{
Assert.AreEqual(p1.Properties[k], p2.Properties[k]);
}
};
Action <List <int>, List <int> > gradesValidator = (l1, l2) =>
{
if (l1 == null || l2 == null)
{
Assert.IsTrue(l1 == null && l2 == null);
return;
}
Assert.AreEqual(l1.Count, l2.Count);
for (int i = 0; i < l1.Count; ++i)
{
Assert.AreEqual(l1[i], l2[i]);
}
};
// Create an object to be serialized
Person p = new Student("Tom")
{
Address = new StreetAddress()
{
FullAddress = new string('B', 1024)
},
Grades = new List <int>()
{
1, 2, 3, 4, 5
}
};
p.Age = 20;
p.DateOfBirth = new DateTime(1980, 5, 12, 10, 2, 45, DateTimeKind.Utc);
p.Properties.Add("height", 6.1);
p.Properties.Add("male", true);
p.Properties.Add("nick-name", "big foot");
byte[] workBuffer = new byte[4096];
ByteBuffer buffer = new ByteBuffer(workBuffer, 0, 0, workBuffer.Length);
AmqpSerializer.Serialize(buffer, p);
Assert.AreEqual(2, p.Version);
// Deserialize and verify
Person p3 = AmqpSerializer.Deserialize <Person>(buffer);
Assert.AreEqual(2, p.Version);
personValidator(p, p3);
Assert.AreEqual(((Student)p).Address.FullAddress, ((Student)p3).Address.FullAddress);
gradesValidator(((Student)p).Grades, ((Student)p3).Grades);
// Inter-op: it should be an AMQP described list as other clients see it
buffer.Seek(0);
DescribedValue dl1 = AmqpSerializer.Deserialize <DescribedValue>(buffer);
Assert.AreEqual(dl1.Descriptor, 0x0000123400000001UL);
List lv = dl1.Value as List;
Assert.IsTrue(lv != null);
Assert.AreEqual(p.Name, lv[0]);
Assert.AreEqual(p.Age, lv[1]);
Assert.AreEqual(p.DateOfBirth.Value, lv[2]);
Assert.IsTrue(lv[3] is DescribedValue, "Address is decribed type");
Assert.AreEqual(((DescribedValue)lv[3]).Descriptor, 0x0000123400000003UL);
Assert.AreEqual(((List)((DescribedValue)lv[3]).Value)[0], ((Student)p).Address.FullAddress);
Assert.IsTrue(lv[4] is Map, "Properties should be map");
Assert.AreEqual(((Map)lv[4])["height"], p.Properties["height"]);
Assert.AreEqual(((Map)lv[4])["male"], p.Properties["male"]);
Assert.AreEqual(((Map)lv[4])["nick-name"], p.Properties["nick-name"]);
Assert.IsTrue(lv[5] is List);
// Non-default serializer
AmqpSerializer serializer = new AmqpSerializer();
ByteBuffer bf1 = new ByteBuffer(1024, true);
serializer.WriteObject(bf1, p);
Person p4 = serializer.ReadObject <Person>(bf1);
personValidator(p, p4);
// Extensible: more items in the payload should not break
DescribedValue dl2 = new DescribedValue(
new Symbol("test.amqp:teacher"),
new List()
{
"Jerry", 40, null, 50000, lv[4], null, null, "unknown-string", true, new Symbol("unknown-symbol")
});
ByteBuffer bf2 = new ByteBuffer(1024, true);
serializer.WriteObject(bf2, dl2);
serializer.WriteObject(bf2, 100ul);
Person p5 = serializer.ReadObject <Person>(bf2);
Assert.IsTrue(p5 is Teacher);
Assert.IsTrue(p5.DateOfBirth == null); // nullable should work
Assert.AreEqual(100ul, serializer.ReadObject <object>(bf2)); // unknowns should be skipped
Assert.AreEqual(0, bf2.Length);
// teacher
Teacher teacher = new Teacher("Han");
teacher.Age = 30;
teacher.Sallary = 60000;
teacher.Classes = new Dictionary <int, string>()
{
{ 101, "CS" }, { 102, "Math" }, { 205, "Project" }
};
ByteBuffer bf3 = new ByteBuffer(1024, true);
serializer.WriteObject(bf3, teacher);
Person p6 = serializer.ReadObject <Person>(bf3);
Assert.IsTrue(p6 is Teacher);
Assert.AreEqual(teacher.Age + 1, p6.Age);
Assert.AreEqual(teacher.Sallary * 2, ((Teacher)p6).Sallary);
Assert.AreEqual(teacher.Id, ((Teacher)p6).Id);
Assert.AreEqual(teacher.Classes[101], ((Teacher)p6).Classes[101]);
Assert.AreEqual(teacher.Classes[102], ((Teacher)p6).Classes[102]);
Assert.AreEqual(teacher.Classes[205], ((Teacher)p6).Classes[205]);
}
internal abstract void OnDisposition(uint first, uint last, DescribedValue state);
static void Main(string[] args)
{
//Create host and register message processor
var uri = new Uri(Address);
var host = new ContainerHost(new List <Uri>()
{
uri
}, null, uri.UserInfo);
host.RegisterMessageProcessor(MsgProcName, new MessageProcessor());
host.Open();
//Create client
var connection = new Connection(new Address(Address));
var session = new Session(connection);
var sender = new SenderLink(session, "message-client", MsgProcName);
//Send message with an object of the base class as the body
var person = new Person()
{
EyeColor = "brown", Height = 175, Weight = 75
};
SendMessage(sender, "Person", person);
//Send message with an object of a derived class as the body
var student = new Student()
{
GPA = 4.8,
Address = new ListAddress()
{
Street = "123 Main St.", City = "Big Apple", State = "NY", Zip = "12345"
}
};
SendMessage(sender, "Person", student);
//Send message with an object of a derived class as the body
var teacher = new Teacher()
{
Department = "Computer Science",
Classes = new List <string>()
{
"CS101", "CS106", "CS210"
}
};
SendMessage(sender, "Person", teacher);
//Send message with nested simple map as the body
var address = new InternationalAddress()
{
Address = new MapAddress()
{
Street = "123 Main St.", City = "Big Apple", State = "NY", Zip = "12345"
},
Country = "usa"
};
SendMessage(sender, "InternationalAddress", address);
//Send message with an AMQP value (the described list form of a student) as the body
var described = new DescribedValue(
new Symbol("samples.amqpnetlite:student"),
new List()
{
80,
6,
"black",
4.9,
new DescribedValue(
new Symbol("PeerToPeer.CustomType.ListAddress"),
new List()
{
"123 Main St.",
"Big Apple",
"NY",
"12345"
}
)
}
);
SendMessage(sender, "Person", described);
//Send message with an AMQP value (simple map of an InternationalAddress) as the body
var map = new Map()
{
{ "street", "123 Main St." },
{ "city", "Big Apple" },
{ "state", "NY" },
{ "zip", "12345" }
};
SendMessage(sender, "MapAddress", map);
//Send message with an AMQP value (simple map of an InternationalAddress) as the body
var map2 = new Map()
{
{ "address", new Map()
{
{ "street", "123 Main St." }, { "city", "Big Apple" }, { "state", "NY" }, { "zip", "12345" }
} },
{ "country", "usa" }
};
SendMessage(sender, "InternationalAddress", map2);
sender.Close();
session.Close();
connection.Close();
host.Close();
}
public void AmqpCodecMapTest()
{
byte[] workBuffer = new byte[4096];
ByteBuffer buffer = new ByteBuffer(workBuffer, 0, 0, workBuffer.Length);
string strBig = new string('A', 512);
Map map = new Map();
map.Add(new Symbol("boolTrue"), boolTrue);
map.Add(new Symbol("boolFalse"), boolFalse);
map.Add(new Symbol("ubyte"), ubyteValue);
map.Add(new Symbol("ushort"), ushortValue);
map.Add(new Symbol("uint"), uintValue);
map.Add(new Symbol("ulong"), ulongValue);
map.Add(new Symbol("byte"), byteValue);
map.Add(new Symbol("short"), shortValue);
map.Add(new Symbol("int"), intValue);
map.Add(new Symbol("long"), longValue);
map.Add(new Symbol("null"), null);
map.Add(new Symbol("float"), floatValue);
map.Add(new Symbol("double"), doubleValue);
map.Add(new Symbol("char"), charValue);
map.Add(new Symbol("datetime"), dtValue);
map.Add(new Symbol("uuid"), uuidValue);
map.Add(new Symbol("binaryNull"), null);
map.Add(new Symbol("binary8"), bin8ValueBin);
map.Add(new Symbol("binary32"), bin32ValueBin);
map.Add(new Symbol("symbolNull"), (Symbol)null);
map.Add(new Symbol("symbol8"), new Symbol(strValue));
map.Add(new Symbol("symbol32"), new Symbol(strBig));
map.Add(new Symbol("string8"), strValue);
map.Add(new Symbol("string32"), strBig);
map.Add(new Symbol("described1"), described1);
AmqpSerializer.Serialize(buffer, map);
// make sure the size written is correct (it has to be Map32)
// the first byte is FormatCode.Map32
int mapSize = (workBuffer[1] << 24) | (workBuffer[2] << 16) | (workBuffer[3] << 8) | workBuffer[4];
Assert.AreEqual(buffer.Length - 5, mapSize);
Map decMap = AmqpSerializer.Deserialize <Map>(buffer);
Assert.IsTrue(decMap[new Symbol("boolTrue")].Equals(true), "Boolean true expected.");
Assert.IsTrue(decMap[new Symbol("boolFalse")].Equals(false), "Boolean false expected.");
Assert.IsTrue(decMap[new Symbol("ubyte")].Equals(ubyteValue), "UByte value not equal.");
Assert.IsTrue(decMap[new Symbol("ushort")].Equals(ushortValue), "UShort value not equal.");
Assert.IsTrue(decMap[new Symbol("uint")].Equals(uintValue), "UInt value not equal.");
Assert.IsTrue(decMap[new Symbol("ulong")].Equals(ulongValue), "ULong value not equal.");
Assert.IsTrue(decMap[new Symbol("byte")].Equals(byteValue), "Byte value not equal.");
Assert.IsTrue(decMap[new Symbol("short")].Equals(shortValue), "Short value not equal.");
Assert.IsTrue(decMap[new Symbol("int")].Equals(intValue), "Int value not equal.");
Assert.IsTrue(decMap[new Symbol("long")].Equals(longValue), "Long value not equal.");
Assert.IsTrue(decMap[new Symbol("null")] == null, "Null object expected.");
Assert.IsTrue(decMap[new Symbol("float")].Equals(floatValue), "Float value not equal.");
Assert.IsTrue(decMap[new Symbol("double")].Equals(doubleValue), "Double value not equal.");
Assert.IsTrue(decMap[new Symbol("char")].Equals(charValue), "Char value not equal.");
Assert.IsTrue(decMap[new Symbol("datetime")].Equals(dtValue), "TimeStamp value not equal.");
Assert.IsTrue(decMap[new Symbol("uuid")].Equals(uuidValue), "Uuid value not equal.");
Assert.IsTrue(decMap[new Symbol("binaryNull")] == null, "Null binary expected.");
byte[] bin8 = (byte[])decMap[new Symbol("binary8")];
EnsureEqual(bin8, 0, bin8.Length, bin8ValueBin, 0, bin8ValueBin.Length);
byte[] bin32 = (byte[])decMap[new Symbol("binary32")];
EnsureEqual(bin32, 0, bin32.Length, bin32ValueBin, 0, bin32ValueBin.Length);
Assert.IsTrue(decMap[new Symbol("symbolNull")] == null, "Null symbol expected.");
Symbol symDecode = (Symbol)decMap[new Symbol("symbol8")];
Assert.IsTrue(symDecode.Equals((Symbol)strValue), "AmqpSymbol value not equal.");
symDecode = (Symbol)decMap[new Symbol("symbol32")];
Assert.IsTrue(symDecode.Equals((Symbol)strBig), "AmqpSymbol value (big) not equal.");
string strDecode = (string)decMap[new Symbol("string8")];
Assert.IsTrue(strDecode.Equals(strValue), "string value not equal.");
strDecode = (string)decMap[new Symbol("string32")];
Assert.IsTrue(strDecode.Equals(strBig), "string value (big) not equal.");
DescribedValue described = (DescribedValue)decMap[new Symbol("described1")];
Assert.IsTrue(described.Descriptor.Equals(described1.Descriptor), "Described value 1 descriptor is different");
Assert.IsTrue(described.Value.Equals(described1.Value), "Described value 1 value is different");
}
public void AmqpCodecListTest()
{
byte[] workBuffer = new byte[4096];
ByteBuffer buffer = new ByteBuffer(workBuffer, 0, 0, workBuffer.Length);
string strBig = new string('A', 512);
List list = new List();
list.Add(boolTrue);
list.Add(boolFalse);
list.Add(ubyteValue);
list.Add(ushortValue);
list.Add(uintValue);
list.Add(ulongValue);
list.Add(byteValue);
list.Add(shortValue);
list.Add(intValue);
list.Add(longValue);
list.Add(null);
list.Add(floatValue);
list.Add(doubleValue);
list.Add(charValue);
list.Add(dtValue);
list.Add(uuidValue);
list.Add(bin8ValueBin);
list.Add(bin32ValueBin);
list.Add((Symbol)null);
list.Add(new Symbol(strValue));
list.Add(new Symbol(strBig));
list.Add(strValue);
list.Add(strBig);
list.Add(described1);
list.Add(described2);
list.Add(described3);
list.Add(described4);
AmqpSerializer.Serialize(buffer, list);
// make sure the size written is correct (it has to be List32)
// the first byte is FormatCode.List32
int listSize = (workBuffer[1] << 24) | (workBuffer[2] << 16) | (workBuffer[3] << 8) | workBuffer[4];
Assert.AreEqual(buffer.Length - 5, listSize);
IList decList = AmqpSerializer.Deserialize <List>(buffer);
int index = 0;
Assert.IsTrue(decList[index++].Equals(true), "Boolean true expected.");
Assert.IsTrue(decList[index++].Equals(false), "Boolean false expected.");
Assert.IsTrue(decList[index++].Equals(ubyteValue), "UByte value not equal.");
Assert.IsTrue(decList[index++].Equals(ushortValue), "UShort value not equal.");
Assert.IsTrue(decList[index++].Equals(uintValue), "UInt value not equal.");
Assert.IsTrue(decList[index++].Equals(ulongValue), "ULong value not equal.");
Assert.IsTrue(decList[index++].Equals(byteValue), "Byte value not equal.");
Assert.IsTrue(decList[index++].Equals(shortValue), "Short value not equal.");
Assert.IsTrue(decList[index++].Equals(intValue), "Int value not equal.");
Assert.IsTrue(decList[index++].Equals(longValue), "Long value not equal.");
Assert.IsTrue(decList[index++] == null, "Null object expected.");
Assert.IsTrue(decList[index++].Equals(floatValue), "Float value not equal.");
Assert.IsTrue(decList[index++].Equals(doubleValue), "Double value not equal.");
Assert.IsTrue(decList[index++].Equals(charValue), "Char value not equal.");
Assert.IsTrue(decList[index++].Equals(dtValue), "TimeStamp value not equal.");
Assert.IsTrue(decList[index++].Equals(uuidValue), "Uuid value not equal.");
byte[] bin8 = (byte[])decList[index++];
EnsureEqual(bin8, 0, bin8.Length, bin8ValueBin, 0, bin8ValueBin.Length);
byte[] bin32 = (byte[])decList[index++];
EnsureEqual(bin32, 0, bin32.Length, bin32ValueBin, 0, bin32ValueBin.Length);
Assert.IsTrue(decList[index++] == null, "Null symbol expected.");
Symbol symDecode = (Symbol)decList[index++];
Assert.IsTrue(symDecode.Equals((Symbol)strValue), "AmqpSymbol value not equal.");
symDecode = (Symbol)decList[index++];
Assert.IsTrue(symDecode.Equals((Symbol)strBig), "AmqpSymbol value (big) not equal.");
string strDecode = (string)decList[index++];
Assert.IsTrue(strDecode.Equals(strValue), "string value not equal.");
strDecode = (string)decList[index++];
Assert.IsTrue(strDecode.Equals(strBig), "string value (big) not equal.");
DescribedValue described = (DescribedValue)decList[index++];
Assert.IsTrue(described.Descriptor.Equals(described1.Descriptor), "Described value 1 descriptor is different");
Assert.IsTrue(described.Value.Equals(described1.Value), "Described value 1 value is different");
described = (DescribedValue)decList[index++];
Assert.IsTrue(described.Descriptor.Equals(described2.Descriptor), "Described value 2 descriptor is different");
Assert.IsTrue(described.Value.Equals(described2.Value), "Described value 2 value is different");
described = (DescribedValue)decList[index++];
Assert.IsTrue(described.Descriptor.Equals(described3.Descriptor), "Described value 3 descriptor is different");
Assert.IsTrue(described.Value.Equals(described3.Value), "Described value 3 value is different");
described = (DescribedValue)decList[index++];
Assert.IsTrue(described.Descriptor.Equals(described4.Descriptor), "Described value 4 descriptor is different");
EnsureEqual((IList)described.Value, (IList)described4.Value);
}
internal override void OnDisposition(uint first, uint last, DescribedValue state)
{
}
