/// <summary>
/// Unmarshal object using the given stream.
/// </summary>
/// <param name="stream">Stream.</param>
/// <returns>Unmarshalled object.</returns>
protected virtual T Unmarshal <T>(IPortableStream stream)
{
return(_marsh.Unmarshal <T>(stream));
}
public void TestHandles()
{
ICollection<PortableTypeConfiguration> typeCfgs =
new List<PortableTypeConfiguration>();
typeCfgs.Add(new PortableTypeConfiguration(typeof(HandleInner)));
typeCfgs.Add(new PortableTypeConfiguration(typeof(HandleOuter)));
PortableConfiguration cfg = new PortableConfiguration();
cfg.TypeConfigurations = typeCfgs;
PortableMarshaller marsh = new PortableMarshaller(cfg);
HandleOuter outer = new HandleOuter();
outer.Before = "outBefore";
outer.After = "outAfter";
outer.RawBefore = "outRawBefore";
outer.RawAfter = "outRawAfter";
HandleInner inner = new HandleInner();
inner.Before = "inBefore";
inner.After = "inAfter";
inner.RawBefore = "inRawBefore";
inner.RawAfter = "inRawAfter";
outer.Inner = inner;
outer.RawInner = inner;
inner.Outer = outer;
inner.RawOuter = outer;
byte[] bytes = marsh.Marshal(outer);
IPortableObject outerObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
HandleOuter newOuter = outerObj.Deserialize<HandleOuter>();
HandleInner newInner = newOuter.Inner;
CheckHandlesConsistency(outer, inner, newOuter, newInner);
// Get inner object by field.
IPortableObject innerObj = outerObj.Field<IPortableObject>("inner");
newInner = innerObj.Deserialize<HandleInner>();
newOuter = newInner.Outer;
CheckHandlesConsistency(outer, inner, newOuter, newInner);
// Get outer object from inner object by handle.
outerObj = innerObj.Field<IPortableObject>("outer");
newOuter = outerObj.Deserialize<HandleOuter>();
newInner = newOuter.Inner;
CheckHandlesConsistency(outer, inner, newOuter, newInner);
}
public void TestHandlesExclusive([Values(true, false)] bool detached, [Values(true, false)] bool asPortable)
{
var marsh = new PortableMarshaller(new PortableConfiguration
{
TypeConfigurations = new List<PortableTypeConfiguration>
{
new PortableTypeConfiguration(typeof (HandleInner)),
new PortableTypeConfiguration(typeof (HandleOuterExclusive))
}
});
var inner = new HandleInner
{
Before = "inBefore",
After = "inAfter",
RawBefore = "inRawBefore",
RawAfter = "inRawAfter"
};
var outer = new HandleOuterExclusive
{
Before = "outBefore",
After = "outAfter",
RawBefore = "outRawBefore",
RawAfter = "outRawAfter",
Inner = inner,
RawInner = inner
};
inner.Outer = outer;
inner.RawOuter = outer;
var bytes = asPortable
? marsh.Marshal(new PortablesImpl(marsh).ToPortable<IPortableObject>(outer))
: marsh.Marshal(outer);
IPortableObject outerObj;
if (detached)
{
var reader = new PortableReaderImpl(marsh, new Dictionary<long, IPortableTypeDescriptor>(),
new PortableHeapStream(bytes), PortableMode.ForcePortable, null);
reader.DetachNext();
outerObj = reader.Deserialize<IPortableObject>();
}
else
outerObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
HandleOuter newOuter = outerObj.Deserialize<HandleOuter>();
Assert.IsFalse(newOuter == newOuter.Inner.Outer);
Assert.IsFalse(newOuter == newOuter.Inner.RawOuter);
Assert.IsFalse(newOuter == newOuter.RawInner.RawOuter);
Assert.IsFalse(newOuter == newOuter.RawInner.RawOuter);
Assert.IsFalse(newOuter.Inner == newOuter.RawInner);
Assert.IsTrue(newOuter.Inner.Outer == newOuter.Inner.RawOuter);
Assert.IsTrue(newOuter.RawInner.Outer == newOuter.RawInner.RawOuter);
Assert.IsTrue(newOuter.Inner == newOuter.Inner.Outer.Inner);
Assert.IsTrue(newOuter.Inner == newOuter.Inner.Outer.RawInner);
Assert.IsTrue(newOuter.RawInner == newOuter.RawInner.Outer.Inner);
Assert.IsTrue(newOuter.RawInner == newOuter.RawInner.Outer.RawInner);
}
public void TestEnumsReflective()
{
PortableMarshaller marsh =
new PortableMarshaller(new PortableConfiguration
{
TypeConfigurations =
new List<PortableTypeConfiguration> {new PortableTypeConfiguration(typeof (EnumType))}
});
EnumType obj = new EnumType
{
PEnum = TestEnum.Val1,
PEnumArray = new[] {TestEnum.Val2, TestEnum.Val3}
};
byte[] bytes = marsh.Marshal(obj);
IPortableObject portObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
Assert.AreEqual(obj.GetHashCode(), portObj.GetHashCode());
EnumType newObj = portObj.Deserialize<EnumType>();
Assert.AreEqual(obj.PEnum, newObj.PEnum);
Assert.AreEqual(obj.PEnumArray, newObj.PEnumArray);
}
public void TestCollectionsReflective()
{
ICollection<PortableTypeConfiguration> typeCfgs =
new List<PortableTypeConfiguration>();
typeCfgs.Add(new PortableTypeConfiguration(typeof(CollectionsType)));
typeCfgs.Add(new PortableTypeConfiguration(typeof(InnerObjectType)));
PortableConfiguration cfg = new PortableConfiguration();
cfg.TypeConfigurations = typeCfgs;
PortableMarshaller marsh = new PortableMarshaller(cfg);
CollectionsType obj = new CollectionsType();
ArrayList list = new ArrayList();
list.Add(true);
list.Add((byte)1);
list.Add((short)2);
list.Add('a');
list.Add(3);
list.Add((long)4);
list.Add((float)5);
list.Add((double)6);
list.Add("string");
list.Add(Guid.NewGuid());
InnerObjectType innerObj = new InnerObjectType();
innerObj.PInt1 = 1;
innerObj.PInt2 = 2;
list.Add(innerObj);
obj.Col1 = list;
byte[] bytes = marsh.Marshal(obj);
IPortableObject portObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
Assert.AreEqual(obj.GetHashCode(), portObj.GetHashCode());
CollectionsType newObj = portObj.Deserialize<CollectionsType>();
Assert.AreEqual(obj, newObj);
obj.Col1 = null;
Assert.AreEqual(obj, marsh.Unmarshal<CollectionsType>(marsh.Marshal(obj)));
obj.Col1 = list;
obj.Col2 = list;
Assert.AreEqual(obj, marsh.Unmarshal<CollectionsType>(marsh.Marshal(obj)));
obj.Col2 = new TestList();
Assert.AreEqual(obj, marsh.Unmarshal<CollectionsType>(marsh.Marshal(obj)));
}
public void TestDecimalFields()
{
PortableConfiguration cfg = new PortableConfiguration
{
TypeConfigurations = new List<PortableTypeConfiguration>
{
new PortableTypeConfiguration(typeof (DecimalReflective)),
new PortableTypeConfiguration(typeof (DecimalMarshalAware))
}
};
PortableMarshaller marsh = new PortableMarshaller(cfg);
// 1. Test reflective stuff.
DecimalReflective obj1 = new DecimalReflective
{
Val = decimal.Zero,
ValArr = new[] {decimal.One, decimal.MinusOne}
};
IPortableObject portObj = marsh.Unmarshal<IPortableObject>(marsh.Marshal(obj1), PortableMode.ForcePortable);
Assert.AreEqual(obj1.Val, portObj.Field<decimal>("val"));
Assert.AreEqual(obj1.ValArr, portObj.Field<decimal[]>("valArr"));
Assert.AreEqual(obj1.Val, portObj.Deserialize<DecimalReflective>().Val);
Assert.AreEqual(obj1.ValArr, portObj.Deserialize<DecimalReflective>().ValArr);
// 2. Test marshal aware stuff.
DecimalMarshalAware obj2 = new DecimalMarshalAware();
obj2.Val = decimal.Zero;
obj2.ValArr = new[] { decimal.One, decimal.MinusOne };
obj2.RawVal = decimal.MaxValue;
obj2.RawValArr = new[] { decimal.MinusOne, decimal.One} ;
portObj = marsh.Unmarshal<IPortableObject>(marsh.Marshal(obj2), PortableMode.ForcePortable);
Assert.AreEqual(obj2.Val, portObj.Field<decimal>("val"));
Assert.AreEqual(obj2.ValArr, portObj.Field<decimal[]>("valArr"));
Assert.AreEqual(obj2.Val, portObj.Deserialize<DecimalMarshalAware>().Val);
Assert.AreEqual(obj2.ValArr, portObj.Deserialize<DecimalMarshalAware>().ValArr);
Assert.AreEqual(obj2.RawVal, portObj.Deserialize<DecimalMarshalAware>().RawVal);
Assert.AreEqual(obj2.RawValArr, portObj.Deserialize<DecimalMarshalAware>().RawValArr);
}
private void CheckPrimitiveFieldsSerialization(PortableMarshaller marsh, PrimitiveFieldType obj)
{
byte[] bytes = marsh.Marshal(obj);
IPortableObject portObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
Assert.AreEqual(obj.GetHashCode(), portObj.GetHashCode());
PrimitiveFieldType newObj = portObj.Deserialize<PrimitiveFieldType>();
Assert.AreEqual(obj, newObj);
}
public void TestProperty()
{
ICollection<PortableTypeConfiguration> typeCfgs =
new List<PortableTypeConfiguration>();
typeCfgs.Add(new PortableTypeConfiguration(typeof(PropertyType)));
PortableConfiguration cfg = new PortableConfiguration {TypeConfigurations = typeCfgs};
PortableMarshaller marsh = new PortableMarshaller(cfg);
PropertyType obj = new PropertyType
{
Field1 = 1,
Field2 = 2
};
byte[] data = marsh.Marshal(obj);
PropertyType newObj = marsh.Unmarshal<PropertyType>(data);
Assert.AreEqual(obj.Field1, newObj.Field1);
Assert.AreEqual(obj.Field2, newObj.Field2);
IPortableObject portNewObj = marsh.Unmarshal<IPortableObject>(data, PortableMode.ForcePortable);
Assert.AreEqual(obj.Field1, portNewObj.Field<int>("field1"));
Assert.AreEqual(obj.Field2, portNewObj.Field<int>("Field2"));
}
public void TestDateObject()
{
ICollection<PortableTypeConfiguration> typeCfgs =
new List<PortableTypeConfiguration>();
typeCfgs.Add(new PortableTypeConfiguration(typeof(DateTimeType)));
PortableConfiguration cfg = new PortableConfiguration {TypeConfigurations = typeCfgs};
PortableMarshaller marsh = new PortableMarshaller(cfg);
DateTime now = DateTime.Now;
DateTimeType obj = new DateTimeType(now);
DateTimeType otherObj = marsh.Unmarshal<DateTimeType>(marsh.Marshal(obj));
Assert.AreEqual(obj.Loc, otherObj.Loc);
Assert.AreEqual(obj.Utc, otherObj.Utc);
Assert.AreEqual(obj.LocNull, otherObj.LocNull);
Assert.AreEqual(obj.UtcNull, otherObj.UtcNull);
Assert.AreEqual(obj.LocArr, otherObj.LocArr);
Assert.AreEqual(obj.UtcArr, otherObj.UtcArr);
Assert.AreEqual(obj.LocRaw, otherObj.LocRaw);
Assert.AreEqual(obj.UtcRaw, otherObj.UtcRaw);
Assert.AreEqual(obj.LocNullRaw, otherObj.LocNullRaw);
Assert.AreEqual(obj.UtcNullRaw, otherObj.UtcNullRaw);
Assert.AreEqual(obj.LocArrRaw, otherObj.LocArrRaw);
Assert.AreEqual(obj.UtcArrRaw, otherObj.UtcArrRaw);
}
private static void CheckObject(PortableMarshaller marsh, OuterObjectType outObj, InnerObjectType inObj)
{
inObj.PInt1 = 1;
inObj.PInt2 = 2;
outObj.InObj = inObj;
byte[] bytes = marsh.Marshal(outObj);
IPortableObject portOutObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
Assert.AreEqual(outObj.GetHashCode(), portOutObj.GetHashCode());
OuterObjectType newOutObj = portOutObj.Deserialize<OuterObjectType>();
Assert.AreEqual(outObj, newOutObj);
}
private static void CheckKeepSerialized(PortableConfiguration cfg, bool expKeep)
{
if (cfg.TypeConfigurations == null)
{
cfg.TypeConfigurations = new List<PortableTypeConfiguration>
{
new PortableTypeConfiguration(typeof(PropertyType))
};
}
PortableMarshaller marsh = new PortableMarshaller(cfg);
byte[] data = marsh.Marshal(new PropertyType());
IPortableObject portNewObj = marsh.Unmarshal<IPortableObject>(data, PortableMode.ForcePortable);
PropertyType deserialized1 = portNewObj.Deserialize<PropertyType>();
PropertyType deserialized2 = portNewObj.Deserialize<PropertyType>();
Assert.NotNull(deserialized1);
Assert.AreEqual(expKeep, deserialized1 == deserialized2);
}
public void TestSpecialArrays()
{
ICollection<PortableTypeConfiguration> typeCfgs =
new List<PortableTypeConfiguration>();
typeCfgs.Add(new PortableTypeConfiguration(typeof(SpecialArray)));
typeCfgs.Add(new PortableTypeConfiguration(typeof(SpecialArrayMarshalAware)));
PortableConfiguration cfg = new PortableConfiguration();
cfg.TypeConfigurations = typeCfgs;
PortableMarshaller marsh = new PortableMarshaller(cfg);
Guid[] guidArr = { Guid.NewGuid() };
Guid?[] nGuidArr = { Guid.NewGuid() };
DateTime[] dateArr = { DateTime.Now.ToUniversalTime() };
DateTime?[] nDateArr = { DateTime.Now.ToUniversalTime() };
// Use special object.
SpecialArray obj1 = new SpecialArray();
obj1.GuidArr = guidArr;
obj1.NGuidArr = nGuidArr;
obj1.DateArr = dateArr;
obj1.NDateArr = nDateArr;
byte[] bytes = marsh.Marshal(obj1);
IPortableObject portObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
Assert.AreEqual(guidArr, portObj.Field<Guid[]>("guidArr"));
Assert.AreEqual(nGuidArr, portObj.Field<Guid?[]>("nGuidArr"));
Assert.AreEqual(dateArr, portObj.Field<DateTime[]>("dateArr"));
Assert.AreEqual(nDateArr, portObj.Field<DateTime?[]>("nDateArr"));
obj1 = portObj.Deserialize<SpecialArray>();
Assert.AreEqual(guidArr, obj1.GuidArr);
Assert.AreEqual(nGuidArr, obj1.NGuidArr);
Assert.AreEqual(dateArr, obj1.DateArr);
Assert.AreEqual(nDateArr, obj1.NDateArr);
// Use special with IGridPortableMarshalAware.
SpecialArrayMarshalAware obj2 = new SpecialArrayMarshalAware();
obj2.GuidArr = guidArr;
obj2.NGuidArr = nGuidArr;
obj2.DateArr = dateArr;
obj2.NDateArr = nDateArr;
bytes = marsh.Marshal(obj2);
portObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
Assert.AreEqual(guidArr, portObj.Field<Guid[]>("a"));
Assert.AreEqual(nGuidArr, portObj.Field<Guid?[]>("b"));
Assert.AreEqual(dateArr, portObj.Field<DateTime[]>("c"));
Assert.AreEqual(nDateArr, portObj.Field<DateTime?[]>("d"));
obj2 = portObj.Deserialize<SpecialArrayMarshalAware>();
Assert.AreEqual(guidArr, obj2.GuidArr);
Assert.AreEqual(nGuidArr, obj2.NGuidArr);
Assert.AreEqual(dateArr, obj2.DateArr);
Assert.AreEqual(nDateArr, obj2.NDateArr);
}
