public void Multistep_Serialization_References_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
var writer = new ObjectWriter(stream);
var primitiveClass1 = new PrimitiveTestClass();
primitiveClass1.Float = 20.5f;
primitiveClass1.Integer = 77;
writer.Write(primitiveClass1);
writer.Write(primitiveClass1);
}
var reader = new ObjectReader(stream);
var readPrimitiveClass1 = reader.Read() as PrimitiveTestClass;
Assert.AreEqual(readPrimitiveClass1.Float, 20.5f);
Assert.AreEqual(readPrimitiveClass1.Integer, 77);
var readPrimitiveClass2 = reader.Read() as PrimitiveTestClass;
Assert.AreSame(readPrimitiveClass1, readPrimitiveClass2);
}
}
public void Multistep_Serialization_References_Static_NonStatic_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
var myClass = new PrimitiveTestClass();
StaticPrimitiveContainer.TestClass = myClass;
StaticPrimitiveContainer.TestClass.Float = 5.7f;
StaticPrimitiveContainer.TestClass.Integer = 32;
var assembly = Assembly.GetExecutingAssembly();
var writer = new ObjectWriter(stream);
writer.WriteStatics(assembly);
writer.Write(myClass);
}
var reader = new ObjectReader(stream);
reader.ReadStatics();
Assert.AreEqual(StaticPrimitiveContainer.TestClass.Float, 5.7f);
var readClass = reader.Read() as PrimitiveTestClass;
Assert.AreSame(readClass, StaticPrimitiveContainer.TestClass);
}
}
public void Generic_List_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
var list = new List <int>();
for (var i = 0; i < 5; i++)
{
list.Add(1 << i);
}
var writer = new ObjectWriter(stream);
writer.Write(list);
}
var reader = new ObjectReader(stream);
var readObject = reader.Read();
Assert.AreSame(readObject.GetType(), typeof(List <int>));
var parsedObject = (List <int>)readObject;
Assert.AreEqual(parsedObject.Count, 5);
for (var i = 0; i < parsedObject.Count; i++)
{
Assert.IsTrue((parsedObject[i] & (parsedObject[i] - 1)) == 0);
}
}
}
public void Polymorphism_Array_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
var animals = new Animal[2];
animals[0] = new Dog();
animals[1] = new Cat();
var writer = new ObjectWriter(stream);
writer.Write(animals);
}
var reader = new ObjectReader(stream);
var readObject = reader.Read();
Assert.AreSame(readObject.GetType(), typeof(Animal[]));
var animalArray = readObject as Animal[];
Assert.AreEqual(animalArray.Length, 2);
Assert.AreEqual(animalArray[0].GetType(), typeof(Dog));
Assert.AreEqual(animalArray[1].GetType(), typeof(Cat));
}
}
public void Generic_Dictionary_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
var dictionary = new Dictionary <string, float>();
dictionary["first"] = 10.7f;
dictionary["second"] = 17.5f;
var writer = new ObjectWriter(stream);
writer.Write(dictionary);
}
stream.Position = 0;
var streamReader = new StreamReader(stream);
var readString = streamReader.ReadToEnd();
var reader = new ObjectReader(stream);
var readObject = reader.Read();
Assert.AreSame(readObject.GetType(), typeof(Dictionary <string, float>));
var parsedObject = readObject as Dictionary <string, float>;
Assert.AreEqual(parsedObject.Count, 2);
Assert.IsTrue(parsedObject.ContainsKey("first"));
Assert.IsTrue(parsedObject.ContainsKey("second"));
Assert.AreEqual(parsedObject["first"], 10.7f);
Assert.AreEqual(parsedObject["second"], 17.5f);
}
}
private ObjectSet <T> GetObjectSet <T>(ObjectReader reader)
{
ObjectSet <T> objectSet = null;
try {
objectSet = new ObjectSet <T>(reader.PageIndex, reader.PageCount, reader.TotalCount);
while (reader.Read())
{
T entityObject = (T)reader.Current();
object keyValue = reader.ObjectKey();
objectSet.Add(keyValue, entityObject);
}
}
catch (ORMapperException) {
throw;
}
catch (Exception exception) {
throw new ORMapperException("GetObjectSet<T> failed for " + reader.ObjectType.ToString(), exception);
}
finally {
if (reader != null)
{
reader.Close();
}
}
return(objectSet);
}
public object GetObject(Type objectType, object objectKey, bool firstLevel)
{
if (objectKey == null)
{
return(null);
}
object entityObject = null;
EntityKey entityKey = new EntityKey(objectType, objectKey);
if (this.instances.Contains(entityKey))
{
EntityMap map = this.Mappings[objectType];
if (map.AutoTrack)
{
Instance instance = (Instance)this.instances[entityKey];
entityObject = instance.EntityObject;
}
}
if (entityObject == null)
{
Commands commands = this.Mappings.Commands(objectType);
using (ObjectReader reader = this.GetObjectReader(commands.KeyQuery(objectType, objectKey), firstLevel)) {
if (reader.Read())
{
entityObject = reader.Current();
}
}
}
return(entityObject);
}
public void Primitives_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
var testObject = new PrimitiveTestClass();
testObject.Integer = 75;
testObject.Float = 13.37f;
var writer = new ObjectWriter(stream);
writer.Write(testObject);
}
var reader = new ObjectReader(stream);
var readObject = reader.Read();
Assert.AreSame(readObject.GetType(), typeof(PrimitiveTestClass));
var parsedObject = (PrimitiveTestClass)readObject;
Assert.AreEqual(parsedObject.Integer, 75);
Assert.AreEqual(parsedObject.Float, 13.37f);
}
}
void Check <T>(T value, Action <T, T> assertTEqual = null)
{
var wrap = new SimpleClass <T>();
wrap.Set(value);
var sb = new StringBuilder();
var writer = new ObjectWriter(new PrimitiveTextWriter(new StringWriter(sb)));
writer.Write(wrap);
var text = sb.ToString();
var reader = new ObjectReader(new PrimitiveTextReader(new StringReader(text)));
var clone = reader.Read();
Assert.IsType <SimpleClass <T> >(clone);
var tclone = (SimpleClass <T>)clone;
tclone.AssertClonningSuccess(value, assertTEqual);
// this is a tad different, it uses BinaryWriter and an internal flag that write less TypeSurrogate info
var clone2 = Serializer.Clone(wrap);
clone2.AssertClonningSuccess(value, assertTEqual);
}
private static void ReadMeExample2()
{
byte[] bytes = { 25, 26, 27, 28, 29, 30, 31 };
var reader = new ObjectReader <Foo>(bytes);
var frame = new Foo();
reader.Read(frame);
}
// Jeff Lanning ([email protected]): Added for OPath support. public object GetObject(CompiledQuery query, bool firstLevel, object[] parameters) { //NOTE: Longhorn 4074 throws an exception if more than one record is returned. // Decided it was better (and faster) not to do the same. using (ObjectReader reader = this.GetObjectReader(query, true, parameters)) { return((reader.Read()) ? reader.Current() : null); } }
public void Generic_Dictionary_With_Key_References_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
var dictionary = new Dictionary <PrimitiveTestClass, int>();
var firstPrimitive = new PrimitiveTestClass();
firstPrimitive.Float = 70.5f;
dictionary[firstPrimitive] = 1;
var secondPrimitive = new PrimitiveTestClass();
secondPrimitive.Float = 85.7f;
dictionary[secondPrimitive] = 0;
var writer = new ObjectWriter(stream);
writer.Write(dictionary);
writer.Write(firstPrimitive);
writer.Write(secondPrimitive);
}
var reader = new ObjectReader(stream);
var readDictionary = reader.Read() as Dictionary <PrimitiveTestClass, int>;
var firstReadPrimitive = reader.Read() as PrimitiveTestClass;
var secondReadPrimitive = reader.Read() as PrimitiveTestClass;
var keyEnumerator = readDictionary.Keys.GetEnumerator();
keyEnumerator.MoveNext();
Assert.AreSame(keyEnumerator.Current, firstReadPrimitive);
keyEnumerator.MoveNext();
Assert.AreSame(keyEnumerator.Current, secondReadPrimitive);
Assert.True(readDictionary.ContainsKey(firstReadPrimitive));
Assert.True(readDictionary.ContainsKey(secondReadPrimitive));
Assert.AreEqual(readDictionary[firstReadPrimitive], 1);
Assert.AreEqual(readDictionary[secondReadPrimitive], 0);
}
}
private static void ObjectReaderSample()
{
byte[] bytes = { 255, 0, 255, 5, 13, 170 };
var frame = new FooFrame();
var reader = new ObjectReader <FooFrame>(bytes);
reader.Read(frame);
Console.WriteLine(frame.Foo); //-65281
Console.WriteLine(frame.Spam); //3333
Console.WriteLine(frame.Bar); //42
Console.WriteLine(frame.Eggs); //-2
}
public void CreateSimpleObject()
{
using (Stream stream = new MemoryStream())
using (ObjectWriter wr = new ObjectWriter(new BinaryWriter(stream)))
using (BinaryReader br = new BinaryReader(stream))
{
wr.Write(new SampleClass());
stream.Seek(0, SeekOrigin.Begin);
ObjectReader target = new ObjectReader(br);
var result = target.Read <SampleClass>();
Assert.IsInstanceOfType(result, typeof(SampleClass));
}
}
public void AssemblyLoad()
{
using (var stream = new MemoryStream())
{
{
var myAssembly = AppDomain.CurrentDomain.GetAssemblies()[1];
var writer = new ObjectWriter(stream);
writer.Write(myAssembly);
}
var reader = new ObjectReader(stream);
var readAssembly = reader.Read() as Assembly;
}
}
public void Delegate_Null_Target_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
var handler = new Action(EmptyFunction);
handler += () => MyFunction();
var writer = new ObjectWriter(stream);
writer.Write(handler);
}
var reader = new ObjectReader(stream);
var readHolder = reader.Read() as Action;
}
}
public void PropertyDefaultValue()
{
using (var stream = new MemoryStream())
{
{
var myClass = new PropertyHolder();
var writer = new ObjectWriter(stream);
writer.Write(myClass);
}
var reader = new ObjectReader(stream);
var readClass = reader.Read() as PropertyHolder;
Assert.AreEqual(readClass.Float, 800.0);
}
}
public void IntPtr_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
var ptr = new IntPtr(0xDEDEDE);
var writer = new ObjectWriter(stream);
writer.Write(ptr);
}
var reader = new ObjectReader(stream);
var readValue = (IntPtr)reader.Read();
Assert.AreEqual(readValue.ToInt64(), 0xDEDEDE);
}
}
public void Generic_Member_Instance_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
var genericInstance = new GenericInstance <PrimitiveTestClass>();
var writer = new ObjectWriter(stream);
writer.Write(genericInstance);
}
var reader = new ObjectReader(stream);
var readValue = reader.Read() as GenericInstance <PrimitiveTestClass>;
Assert.AreSame(readValue.GetType(), typeof(GenericInstance <PrimitiveTestClass>));
}
}
private System.Collections.ObjectModel.Collection <T> GetCollection <T>(ObjectReader reader)
{
System.Collections.ObjectModel.Collection <T> collection = new System.Collections.ObjectModel.Collection <T>();
try {
while (reader.Read())
{
collection.Add((T)reader.Current());
}
}
finally {
if (reader != null)
{
reader.Close();
}
}
return(collection);
}
public void ReadOnlySerialization_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
var myClass = new ReadOnlyOwnerClass();
var writer = new ObjectWriter(stream);
writer.Write(myClass);
}
var reader = new ObjectReader(stream);
var readClass = reader.Read() as ReadOnlyOwnerClass;
Assert.AreEqual(readClass.test.Float, 5);
}
}
public void CreateSimpleObjectWithIntMember()
{
using (Stream stream = new MemoryStream())
using (ObjectWriter wr = new ObjectWriter(new BinaryWriter(stream)))
using (BinaryReader br = new BinaryReader(stream))
{
const int five = 5;
var simpleObject = new SampleClass {
simpleMember = five
};
wr.Write(simpleObject);
stream.Seek(0, SeekOrigin.Begin);
ObjectReader target = new ObjectReader(br);
var result = target.Read <SampleClass>();
Assert.AreEqual(five, result.simpleMember);
}
}
public void Primitive_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
int myInt = 1337;
var writer = new ObjectWriter(stream);
writer.Write(myInt);
}
var reader = new ObjectReader(stream);
var readInteger = (int)reader.Read();
Assert.AreSame(readInteger.GetType(), typeof(int));
Assert.AreEqual(readInteger, 1337);
}
}
public void ObjectReaderParsesNullableStructs_Test()
{
using (var ms = new MemoryStream(new byte[] { (byte)ObjectType.Instance, 5, 0, 0, 0 }))
{
var v = ObjectReader.Read <int?>(ms);
Assert.NotNull(v);
Assert.Equal(5, v !.Value);
}
using (var ms = new MemoryStream(new byte[] { (byte)ObjectType.Default }))
{
var v = ObjectReader.Read <int?>(ms);
Assert.NotNull(v);
Assert.Equal(0, v !.Value);
}
using (var ms = new MemoryStream(new byte[] { (byte)ObjectType.Null }))
{
Assert.Null(ObjectReader.Read <int?>(ms));
}
}
public void Lambda_Action_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
var actionHolder = new LambdaActionHolder();
var actionOwner = new LambdaActionOwner();
actionHolder.method = () => actionOwner.MyFunction();
var writer = new ObjectWriter(stream);
writer.Write(actionHolder);
}
var reader = new ObjectReader(stream);
var readHolder = reader.Read() as LambdaActionHolder;
//Assert.AreEqual(readHolder.method.Target.GetType(), typeof(LambaActionOwner));
}
}
public void ObjectReference_Test_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
var value = new MyReferenceClass();
value.testClassCopy = value.testClass;
Assert.AreSame(value.testClass, value.testClassCopy);
var writer = new ObjectWriter(stream);
writer.Write(value);
}
var reader = new ObjectReader(stream);
var readValue = reader.Read() as MyReferenceClass;
Assert.AreSame(readValue.testClass, readValue.testClassCopy);
}
}
public void Enum_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
var myEnum = TestEnumeration.Second;
var writer = new ObjectWriter(stream);
writer.Write(myEnum);
}
var reader = new ObjectReader(stream);
var readObject = reader.Read();
Assert.AreSame(readObject.GetType(), typeof(TestEnumeration));
var enumObject = (TestEnumeration)readObject;
Assert.AreEqual(enumObject, TestEnumeration.Second);
}
}
public void ObjectReaderParsesArray_Test()
{
using (var ms = new MemoryStream(new byte[]
{
3, 0, 0, 0,
1, 0, 0, 0,
2, 0, 0, 0,
3, 0, 0, 0
}))
{
Assert.Equal(new int[] { 1, 2, 3 }, ObjectReader.Read <int[]>(ms));
}
using (var ms = new MemoryStream(new byte[] { 0, 0, 0, 0 }))
{
Assert.Equal(Array.Empty <int>(), ObjectReader.Read <int[]>(ms));
}
using (var ms = new MemoryStream(new byte[] { 255, 255, 255, 255 }))
{
Assert.Null(ObjectReader.Read <int[]>(ms));
}
}
private IList GetCollection(Type collectionType, ObjectReader reader)
{
IList collection = null;
if (collectionType == typeof(ObjectSet))
{
collection = new ObjectSet(reader.ObjectType, reader.PageIndex, reader.PageCount, reader.TotalCount);
}
else if (collectionType == typeof(ObjectList))
{
ObjectSet objectSet = new ObjectSet(reader.ObjectType, reader.PageIndex, reader.PageCount, reader.TotalCount);
collection = new ObjectList(this, objectSet);
}
else
{
collection = (IList)Activator.CreateInstance(collectionType, true);
}
try {
while (reader.Read())
{
if (collectionType == typeof(IObjectSet))
{
((IObjectSet)collection).Add(reader.ObjectKey(), reader.Current());
}
else
{
collection.Add(reader.Current());
}
}
}
finally {
if (reader != null)
{
reader.Close();
}
}
return(collection);
}
public void String_With_MemoryStream()
{
using (var stream = new MemoryStream())
{
{
StringTestClass testObject = new StringTestClass();
testObject.String = "This string was brought to you by Crytek";
var writer = new ObjectWriter(stream);
writer.Write(testObject);
}
var reader = new ObjectReader(stream);
var readObject = reader.Read();
Assert.AreSame(readObject.GetType(), typeof(StringTestClass));
var parsedObject = (StringTestClass)readObject;
Assert.AreEqual(parsedObject.String, "This string was brought to you by Crytek");
}
}
public void Test_ObjectReader_NotObject()
{
var raw = "%Comment";
var stream = new MemoryStream(Encoding.ASCII.GetBytes(raw));
var reader = new ObjectReader(stream, null);
var obj = reader.Read();
Assert.IsNull(obj);
Assert.AreEqual(0, stream.Position);
stream.Dispose();
raw = "0 0 obj\r\n5\r\nendobj";
stream = new MemoryStream(Encoding.ASCII.GetBytes(raw));
reader = new ObjectReader(stream, null);
obj = reader.Read();
Assert.IsNull(obj);
Assert.AreEqual(0, stream.Position);
stream.Dispose();
raw = "2 -5 obj\r\n5\r\nendobj";
stream = new MemoryStream(Encoding.ASCII.GetBytes(raw));
reader = new ObjectReader(stream, null);
obj = reader.Read();
Assert.IsNull(obj);
Assert.AreEqual(0, stream.Position);
stream.Dispose();
}
public void Test_ObjectReader_UnknownType()
{
const string raw = "1 0 obj\r\nsomething unknown\r\nendobj";
var stream = new MemoryStream(Encoding.ASCII.GetBytes(raw));
var reader = new ObjectReader(stream, null);
try
{
reader.Read();
}
finally
{
stream.Dispose();
}
}
public void Test_ObjectReader_UnexpectedEndOfObject()
{
const string raw = "1 0 obj\r\n0\r\n5";
var stream = new MemoryStream(Encoding.ASCII.GetBytes(raw));
var reader = new ObjectReader(stream, null);
try
{
reader.Read();
}
finally
{
stream.Dispose();
}
}
public void Test_ObjectReader_Regular()
{
const string raw = "1 0 obj\r\n200\r\nendobj\r\n2 3 obj\r\n-12.5\r\nendobj";
var stream = new MemoryStream(Encoding.ASCII.GetBytes(raw));
var reader = new ObjectReader(stream, null);
var obj = reader.Read();
Assert.IsNotNull(obj);
Assert.AreEqual(200, ((IntegerObject) obj).Value);
Assert.AreEqual(1u, obj.Number);
Assert.AreEqual(0u, obj.Generation);
obj = reader.Read();
Assert.IsNotNull(obj);
Assert.AreEqual(-12.5f, ((RealObject) obj).Value);
Assert.AreEqual(2u, obj.Number);
Assert.AreEqual(3u, obj.Generation);
stream.Dispose();
}
