public IEnumerable <IPersistenceObject> SetObjects(IZetboxContext ctx, IEnumerable <IPersistenceObject> objects, IEnumerable <ObjectNotificationRequest> notficationRequests)
{
IEnumerable <IPersistenceObject> result = null;
// Serialize
using (var ms = new MemoryStream())
using (var sw = new ZetboxStreamWriter(_map, new BinaryWriter(ms)))
{
SendObjects(objects, sw);
var handler = _memoryFactory.GetServerObjectSetHandler();
var changedObjects = handler
.SetObjects(ZetboxGeneratedVersionAttribute.Current, _backingStore, objects, notficationRequests ?? new ObjectNotificationRequest[0])
.Cast <IStreamable>();
var bytes = SendObjects(changedObjects, true).ToArray();
using (var sr = new ZetboxStreamReader(_map, new BinaryReader(new MemoryStream(bytes))))
{
// merge auxiliary objects into primary set objects result
List <IStreamable> auxObjects;
var receivedObjects = ReceiveObjects(ctx, sr, out auxObjects);
result = receivedObjects.Concat(auxObjects).Cast <IPersistenceObject>();
}
}
return(result);
}
/// <summary>
/// Serializes a list of objects onto a <see cref="MemoryStream"/>.
/// </summary>
/// <param name="lst">the list of objects to send</param>
/// <param name="eagerLoadLists">True if Lists should be eager loaded</param>
/// <returns>a memory stream containing all objects and all eagerly loaded auxiliary objects</returns>
private MemoryStream SendObjects(IEnumerable <IStreamable> lst, bool eagerLoadLists)
{
HashSet <IStreamable> sentObjects = new HashSet <IStreamable>();
HashSet <IStreamable> auxObjects = new HashSet <IStreamable>();
MemoryStream result = new MemoryStream();
ZetboxStreamWriter sw = new ZetboxStreamWriter(_map, new BinaryWriter(result));
foreach (IStreamable obj in lst)
{
sw.Write(true);
// don't check sentObjects here, because a list might contain items twice
obj.ToStream(sw, auxObjects, eagerLoadLists);
sentObjects.Add(obj);
}
sw.Write(false);
SendAuxiliaryObjects(sw, auxObjects, sentObjects, eagerLoadLists);
// https://connect.microsoft.com/VisualStudio/feedback/details/541494/wcf-streaming-issue
sw.Write(false);
sw.Write(false);
sw.Write(false);
result.Seek(0, SeekOrigin.Begin);
return(result);
}
public void Stream()
{
var typeMap = scope.Resolve <TypeMap>();
using (var ms = new MemoryStream())
using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)))
using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)))
{
var ctx = GetContext();
ctx.Attach(obj);
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
var t = sr.ReadSerializableType();
Assert.That(t.GetSystemType().IsAssignableFrom(typeof(ANewObjectClass)), string.Format("{0} not assignable to {1}", typeof(ANewObjectClass), t));
BaseClientDataObjectMockImpl result = new BaseClientDataObjectMockImpl(null);
result.FromStream(sr);
Assert.That(result.GetType(), Is.EqualTo(obj.GetType()));
Assert.That(result.ID, Is.EqualTo(obj.ID));
Assert.That(result.ObjectState, Is.EqualTo(obj.ObjectState));
}
}
public override void ToStream(ZetboxStreamWriter binStream, HashSet <IStreamable> auxObjects, bool eagerLoadLists)
{
base.ToStream(binStream, auxObjects, eagerLoadLists);
binStream.Write(this._MyIntProperty);
binStream.Write(this._fk_ObjectProp);
binStream.Write(this._StringProp);
binStream.Write((int?)((TestObjClass)this).TestEnumProp);
}
public void ToStream(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, bool eagerLoadLists)
{
sw.Write(ReadOnlyContext.GetInterfaceType(this).ToSerializableType());
sw.Write(ID);
sw.Write(StringProperty);
sw.Write(IntProperty);
sw.Write(BoolProperty);
}
private static void SendObjects(IEnumerable <IPersistenceObject> objects, ZetboxStreamWriter sw)
{
foreach (var obj in objects)
{
sw.Write(true);
obj.ToStream(sw, new HashSet <IStreamable>(), false);
}
sw.Write(false);
}
public override void ToStream(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, bool eagerLoadLists)
{
base.ToStream(sw, auxObjects, eagerLoadLists);
int?id = this.BaseTestObjClass == null ? (int?)null : this.BaseTestObjClass.ID;
sw.Write(id);
sw.Write(this._StringProp);
sw.Write((int)this.TestEnumProp);
sw.WriteCollectionEntries(this.TestNamesImpl);
}
public override void SetUp()
{
base.SetUp();
readerFactory = scope.Resolve<ZetboxStreamReader.Factory>();
writerFactory = scope.Resolve<ZetboxStreamWriter.Factory>();
stream = new MemoryStream();
reader = readerFactory.Invoke(new BinaryReader(stream));
writer = writerFactory.Invoke(new BinaryWriter(stream));
}
public override void SetUp()
{
base.SetUp();
readerFactory = scope.Resolve <ZetboxStreamReader.Factory>();
writerFactory = scope.Resolve <ZetboxStreamWriter.Factory>();
stream = new MemoryStream();
reader = readerFactory.Invoke(new BinaryReader(stream));
writer = writerFactory.Invoke(new BinaryWriter(stream));
}
public ZetboxService(IServerObjectHandlerFactory sohFactory, Func<IZetboxContext> ctxFactory, InterfaceType.Factory iftFactory, IPerfCounter perfCounter, ZetboxStreamReader.Factory readerFactory, ZetboxStreamWriter.Factory writerFactory)
{
if (readerFactory == null) throw new ArgumentNullException("readerFactory");
if (writerFactory == null) throw new ArgumentNullException("writerFactory");
Logging.Facade.Debug("Creating new ZetboxService instance");
_sohFactory = sohFactory;
_ctxFactory = ctxFactory;
_iftFactory = iftFactory;
_perfCounter = perfCounter;
_readerFactory = readerFactory;
_writerFactory = writerFactory;
}
public void should_use_interfacetype_on_the_stream()
{
var typeMap = scope.Resolve <TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
obj.ToStream(sw, null, false);
ms.Seek(0, SeekOrigin.Begin);
var t = sr.ReadSerializableType();
Assert.That(t, Is.EqualTo(_iftFactory(typeof(TestObjClass)).ToSerializableType()));
}
public void ToStream_creates_correct_Stream()
{
var typeMap = scope.Resolve <TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
InitialiseObject(obj);
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
TestObjClassSerializationMock.AssertCorrectContents <TestObjClass, TestEnum>(sr, _iftFactory);
}
/// <summary>
/// Serializes a test TestObjClass to the stream sw.
/// </summary>
/// <param name="sw"></param>
public static void ToStream <LOCALINTERFACE, ENUMTYPE>(ZetboxStreamWriter sw, InterfaceType.Factory iftFactory)
where LOCALINTERFACE : TestObjClass <LOCALINTERFACE, ENUMTYPE>
where ENUMTYPE : struct
{
// BaseServerPersistenceObject
sw.Write(GetSerializableType <LOCALINTERFACE, ENUMTYPE>(iftFactory));
sw.Write(TestObjClassId);
sw.Write((int)TestObjectState);
sw.Write((int)AccessRights.Full);
// TestObjClass
// BaseTestObjClass Reference
sw.Write(TestBaseClassId);
// StringProp
sw.Write(TestStringPropValue);
//// SubClasses are not serialized, but fetched lazily
//foreach (int subClassID in TestSubClassesIds)
//{
// BinarySerializer.ToStream(true, sw);
// BinarySerializer.ToStream(subClassID, sw);
//}
//BinarySerializer.ToStream(false, sw);
// TestEnumProp
sw.Write((int)TestEnum.TestSerializationValue);
// TestNames
var ceType = GetSerializableCollectionEntryType <LOCALINTERFACE, ENUMTYPE>(iftFactory);
for (int i = 0; i < TestTestNamesIds.Length; i++)
{
sw.Write(true);
sw.Write(ceType);
sw.Write(TestTestNamesIds[i]);
sw.Write((int)TestCollectionEntryState);
sw.Write((int)AccessRights.Full);
sw.Write(TestTestNamesValues[i]);
}
sw.Write(false);
}
public HttpServiceClient(ICredentialsResolver credentialsResolver, ZetboxStreamReader.Factory readerFactory, ZetboxStreamWriter.Factory writerFactory)
{
if (credentialsResolver == null) throw new ArgumentNullException("credentialsResolver");
if (readerFactory == null) throw new ArgumentNullException("readerFactory");
if (writerFactory == null) throw new ArgumentNullException("writerFactory");
SetObjectsUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/SetObjects");
GetObjectsUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/GetObjects");
GetListOfUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/GetListOf");
FetchRelationUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/FetchRelation");
GetBlobStreamUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/GetBlobStream");
SetBlobStreamUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/SetBlobStream");
InvokeServerMethodUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/InvokeServerMethod");
_credentialsResolver = credentialsResolver;
_readerFactory = readerFactory;
_writerFactory = writerFactory;
}
public void ToStream_creates_correct_Stream()
{
var typeMap = scope.Resolve <TypeMap>();
using (var ms = new MemoryStream())
using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)))
using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)))
{
InitialiseObject(ctx, obj);
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
Assert.Ignore("need to implement mocked serialization for ObjectClass");
//TestObjClassSerializationMock.AssertCorrectContents<TestObjClass, int>(sr);
}
}
public void FromStream_Attached()
{
var typeMap = scope.Resolve<TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
var ctxMock = GetContext();
TestObjClass result = ctxMock.Create<TestObjClass>();
Assert.That(result.IsAttached, Is.True);
Assert.That(() => result.FromStream(sr), Throws.InstanceOf<InvalidOperationException>());
}
public void FromStream_Attached()
{
var typeMap = scope.Resolve <TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
var ctxMock = GetContext();
TestObjClass result = ctxMock.Create <TestObjClass>();
Assert.That(result.IsAttached, Is.True);
Assert.That(() => result.FromStream(sr), Throws.InstanceOf <InvalidOperationException>());
}
public void Stream()
{
var typeMap = scope.Resolve <TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
TestCompoundObject result = new TestCompoundObject();
result.FromStream(sr);
Assert.That(result.TestInt, Is.EqualTo(obj.TestInt));
Assert.That(result.TestString, Is.EqualTo(obj.TestString));
}
public void FromStream_creates_correct_Object()
{
var typeMap = scope.Resolve <TypeMap>();
using (var ms = new MemoryStream())
using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)))
using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)))
{
Assert.Ignore("need to implement mocked serialization for ObjectClass");
//TestObjClassSerializationMock.ToStream<TestObjClass, int>(sw);
sw.Flush();
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
obj.FromStream(sr);
//TestObjClassSerializationMock.AssertCorrectContentsInt<TestObjClass>(objImpl);
}
}
public void FromStream_Attached_fails()
{
var typeMap = scope.Resolve <TypeMap>();
using (var ms = new MemoryStream())
using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)))
using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)))
{
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
using (var ctx = GetContext())
{
var result = ctx.Create <ObjectClass>();
result.FromStream(sr);
}
}
}
public void FromStream_creates_correct_Object()
{
var typeMap = scope.Resolve<TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
TestObjClassSerializationMock.ToStream<TestObjClass, TestEnum>(sw, _iftFactory);
sw.Flush();
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
var t = sr.ReadSerializableType();
Assert.That(t.GetSystemType().IsAssignableFrom(typeof(TestObjClass)), string.Format("{0} not assignable to {1}", typeof(TestObjClass), t));
var obj = new TestObjClassImpl();
obj.FromStream(sr);
ctx.Attach(obj);
TestObjClassSerializationMock.AssertCorrectContentsEnum<TestObjClass>(obj);
}
/// <summary>
/// Sends a list of auxiliary objects to the specified ZetboxStreamWriter while avoiding to send objects twice.
/// </summary>
/// <param name="sw">the stream to write to</param>
/// <param name="auxObjects">a set of objects to send; will not be modified by this call</param>
/// <param name="sentObjects">a set objects already sent; receives all newly sent objects too</param>
/// <param name="eagerLoadLists">True if Lists should be eager loaded</param>
private static void SendAuxiliaryObjects(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, HashSet <IStreamable> sentObjects, bool eagerLoadLists)
{
// clone auxObjects to avoid modification
auxObjects = new HashSet <IStreamable>(auxObjects);
auxObjects.ExceptWith(sentObjects);
// send all eagerly loaded objects
while (auxObjects.Count > 0)
{
HashSet <IStreamable> secondTierAuxObjects = new HashSet <IStreamable>();
foreach (var aux in auxObjects.Where(o => o != null))
{
sw.Write(true);
aux.ToStream(sw, secondTierAuxObjects, eagerLoadLists);
sentObjects.Add(aux);
}
// check whether new objects where eagerly loaded
secondTierAuxObjects.ExceptWith(sentObjects);
auxObjects = secondTierAuxObjects;
}
// finish list
sw.Write(false);
}
public void FromStream_creates_correct_Object()
{
var typeMap = scope.Resolve <TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
TestObjClassSerializationMock.ToStream <TestObjClass, TestEnum>(sw, _iftFactory);
sw.Flush();
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
var t = sr.ReadSerializableType();
Assert.That(t.GetSystemType().IsAssignableFrom(typeof(TestObjClass)), string.Format("{0} not assignable to {1}", typeof(TestObjClass), t));
var obj = new TestObjClassImpl();
obj.FromStream(sr);
ctx.Attach(obj);
TestObjClassSerializationMock.AssertCorrectContentsEnum <TestObjClass>(obj);
}
public override void ToStream(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, bool eagerLoadLists)
{
base.ToStream(sw, auxObjects, eagerLoadLists);
sw.Write(TestInt);
sw.Write(TestString);
}
public void ToStream(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, bool eagerLoadLists)
{
}
private void InitStreams()
{
ms = new MemoryStream();
sw = scope.Resolve <ZetboxStreamWriter.Factory>().Invoke(new BinaryWriter(ms));
sr = scope.Resolve <ZetboxStreamReader.Factory>().Invoke(new BinaryReader(ms));
}
public override void ToStream(ZetboxStreamWriter sw, HashSet<IStreamable> auxObjects, bool eagerLoadLists)
{
base.ToStream(sw, auxObjects, eagerLoadLists);
int? id = this.BaseTestObjClass == null ? (int?)null : this.BaseTestObjClass.ID;
sw.Write(id);
sw.Write(this._StringProp);
sw.Write((int)this.TestEnumProp);
sw.WriteCollectionEntries(this.TestNamesImpl);
}
public override void ToStream(ZetboxStreamWriter binStream, HashSet<IStreamable> auxObjects, bool eagerLoadLists)
{
base.ToStream(binStream, auxObjects, eagerLoadLists);
binStream.Write(this._MyIntProperty);
binStream.Write(this._fk_ObjectProp);
binStream.Write(this._StringProp);
binStream.Write((int?)((TestObjClass)this).TestEnumProp);
}
/// <summary>
/// Sends a list of auxiliary objects to the specified ZetboxStreamWriter while avoiding to send objects twice.
/// </summary>
/// <param name="sw">the stream to write to</param>
/// <param name="auxObjects">a set of objects to send; will not be modified by this call</param>
/// <param name="sentObjects">a set objects already sent; receives all newly sent objects too</param>
/// <param name="eagerLoadLists">True if Lists should be eager loaded</param>
private static void SendAuxiliaryObjects(ZetboxStreamWriter sw, HashSet<IStreamable> auxObjects, HashSet<IStreamable> sentObjects, bool eagerLoadLists)
{
// clone auxObjects to avoid modification
auxObjects = new HashSet<IStreamable>(auxObjects);
auxObjects.ExceptWith(sentObjects);
// send all eagerly loaded objects
while (auxObjects.Count > 0)
{
HashSet<IStreamable> secondTierAuxObjects = new HashSet<IStreamable>();
foreach (var aux in auxObjects.Where(o => o != null))
{
sw.Write(true);
aux.ToStream(sw, secondTierAuxObjects, eagerLoadLists);
sentObjects.Add(aux);
}
// check whether new objects where eagerly loaded
secondTierAuxObjects.ExceptWith(sentObjects);
auxObjects = secondTierAuxObjects;
}
// finish list
sw.Write(false);
}
public override void ToStream(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, bool eagerLoadLists)
{
base.ToStream(sw, auxObjects, eagerLoadLists);
sw.Write((int)ObjectState);
sw.Write((int)CurrentAccessRights);
}
public override void ToStream(ZetboxStreamWriter sw, HashSet<IStreamable> auxObjects, bool eagerLoadLists)
{
base.ToStream(sw, auxObjects, eagerLoadLists);
sw.Write((int)ObjectState);
sw.Write((int)CurrentAccessRights);
}
public void ToStream(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, bool eagerLoadLists)
{
throw new NotImplementedException();
}
public void Stream()
{
var typeMap = scope.Resolve<TypeMap>();
using (var ms = new MemoryStream())
using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)))
using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)))
{
var ctx = GetContext();
ctx.Attach(obj);
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
var t = sr.ReadSerializableType();
Assert.That(t.GetSystemType().IsAssignableFrom(typeof(ANewObjectClass)), string.Format("{0} not assignable to {1}", typeof(ANewObjectClass), t));
BaseClientDataObjectMockImpl result = new BaseClientDataObjectMockImpl(null);
result.FromStream(sr);
Assert.That(result.GetType(), Is.EqualTo(obj.GetType()));
Assert.That(result.ID, Is.EqualTo(obj.ID));
Assert.That(result.ObjectState, Is.EqualTo(obj.ObjectState));
}
}
public void ToStream(ZetboxStreamWriter sw, HashSet<IStreamable> auxObjects, bool eagerLoadLists)
{
sw.Write(ReadOnlyContext.GetInterfaceType(this).ToSerializableType());
sw.Write(ID);
sw.Write(StringProperty);
sw.Write(IntProperty);
sw.Write(BoolProperty);
}
public void should_use_interfacetype_on_the_stream()
{
var typeMap = scope.Resolve<TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
obj.ToStream(sw, null, false);
ms.Seek(0, SeekOrigin.Begin);
var t = sr.ReadSerializableType();
Assert.That(t, Is.EqualTo(_iftFactory(typeof(TestObjClass)).ToSerializableType()));
}
public void ToStream_creates_correct_Stream()
{
var typeMap = scope.Resolve<TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
InitialiseObject(obj);
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
TestObjClassSerializationMock.AssertCorrectContents<TestObjClass, TestEnum>(sr, _iftFactory);
}
public override void ToStream(ZetboxStreamWriter sw, HashSet<IStreamable> auxObjects, bool eagerLoadLists)
{
base.ToStream(sw, auxObjects, eagerLoadLists);
sw.Write(TestProperty);
}
public override void ToStream(ZetboxStreamWriter sw, HashSet <IStreamable> auxObjects, bool eagerLoadLists)
{
base.ToStream(sw, auxObjects, eagerLoadLists);
sw.Write(this.Value);
sw.Write(this.fk_Parent);
}
public void ToStream(ZetboxStreamWriter sw, HashSet<IStreamable> auxObjects, bool eagerLoadLists)
{
throw new NotImplementedException();
}
public void Stream()
{
var typeMap = scope.Resolve<TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
TestCompoundObject result = new TestCompoundObject();
result.FromStream(sr);
Assert.That(result.TestInt, Is.EqualTo(obj.TestInt));
Assert.That(result.TestString, Is.EqualTo(obj.TestString));
}
