3 files changed, 142 insertions, 0 deletions

diff --git a/cpp/test/Ice/stream/Client.cpp b/cpp/test/Ice/stream/Client.cpp
index 3e7ee1caf7e..8d460a2313a 100644
--- a/cpp/test/Ice/stream/Client.cpp
+++ b/cpp/test/Ice/stream/Client.cpp
@@ -88,9 +88,43 @@ public:
 };
 typedef IceUtil::Handle<TestReadObjectCallback> TestReadObjectCallbackPtr;
 
+class MyClassFactoryWrapper : public Ice::ObjectFactory
+{
+public:
+
+    MyClassFactoryWrapper() : _factory(Test::MyClass::ice_factory())
+    {
+    }
+
+    virtual Ice::ObjectPtr
+    create(const string& type)
+    {
+	return _factory->create(type);
+    }
+
+    virtual void
+    destroy()
+    {
+    }
+
+    void
+    setFactory(const Ice::ObjectFactoryPtr& factory)
+    {
+	_factory = factory;
+    }
+
+private:
+
+    Ice::ObjectFactoryPtr _factory;
+};
+typedef IceUtil::Handle<MyClassFactoryWrapper> MyClassFactoryWrapperPtr;
+
 int
 run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
 {
+    MyClassFactoryWrapperPtr factoryWrapper = new MyClassFactoryWrapper;
+    communicator->addObjectFactory(factoryWrapper, Test::MyClass::ice_staticId());
+
     Ice::InputStreamPtr in;
     Ice::OutputStreamPtr out;
     vector<Ice::Byte> data;
@@ -420,6 +454,28 @@ run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
         test(writer->called);
     }
 
+    {
+        out = Ice::createOutputStream(communicator);
+        Test::MyClassPtr obj = new Test::MyClass;
+        obj->s.e = Test::enum2;
+        TestObjectWriterPtr writer = new TestObjectWriter(obj);
+        out->writeObject(writer);
+        out->writePendingObjects();
+        out->finished(data);
+        test(writer->called);
+        factoryWrapper->setFactory(new TestObjectFactory);
+        in = Ice::createInputStream(communicator, data);
+        TestReadObjectCallbackPtr cb = new TestReadObjectCallback;
+        in->readObject(cb);
+        in->readPendingObjects();
+        test(cb->obj);
+        TestObjectReaderPtr reader = TestObjectReaderPtr::dynamicCast(cb->obj);
+        test(reader);
+        test(reader->called);
+        test(reader->obj);
+        test(reader->obj->s.e == Test::enum2);
+    }
+
     cout << "ok" << endl;
 
     return 0;
diff --git a/cs/test/Ice/stream/Client.cs b/cs/test/Ice/stream/Client.cs
index 0e2c920efa9..a79c2a833f4 100644
--- a/cs/test/Ice/stream/Client.cs
+++ b/cs/test/Ice/stream/Client.cs
@@ -112,8 +112,39 @@ public class Client
         internal Ice.Object obj;
     }
 
+    public class MyClassFactoryWrapper : Ice.LocalObjectImpl, Ice.ObjectFactory
+    {
+	public MyClassFactoryWrapper()
+	{
+	    _factory = null;
+	}
+
+        public Ice.Object create(string type)
+        {
+	    if(_factory != null)
+	    {
+		return _factory.create(type);
+	    }
+	    return new Test.MyClass();
+        }
+
+        public void destroy()
+        {
+        }
+
+	public void setFactory(Ice.ObjectFactory factory)
+	{
+	    _factory = factory;
+	}
+
+	private Ice.ObjectFactory _factory;
+    }
+
     private static int run(string[] args, Ice.Communicator communicator)
     {
+	MyClassFactoryWrapper factoryWrapper = new MyClassFactoryWrapper();
+	communicator.addObjectFactory(factoryWrapper, Test.MyClass.ice_staticId());
+
         Ice.InputStream @in;
         Ice.OutputStream @out;
 
@@ -459,8 +490,21 @@ public class Client
             TestObjectWriter writer = new TestObjectWriter(obj);
             @out.writeObject(writer);
             @out.writePendingObjects();
+            byte[] data = @out.finished();
             test(writer.called);
+            factoryWrapper.setFactory(new TestObjectFactory());
+            @in = Ice.Util.createInputStream(communicator, data);
+            TestReadObjectCallback cb = new TestReadObjectCallback();
+            @in.readObject(cb);
+            @in.readPendingObjects();
+            test(cb.obj != null);
+            test(cb.obj is TestObjectReader);
+            TestObjectReader reader = (TestObjectReader)cb.obj;
+            test(reader.called);
+            test(reader.obj != null);
+            test(reader.obj.s.e == Test.MyEnum.enum2);
             @out.destroy();
+            @in.destroy();
         }
 
         Console.WriteLine("ok");
diff --git a/java/test/Ice/stream/Client.java b/java/test/Ice/stream/Client.java
index 8289ad55d18..4078f1fb085 100644
--- a/java/test/Ice/stream/Client.java
+++ b/java/test/Ice/stream/Client.java
@@ -76,9 +76,39 @@ public class Client
         Ice.Object obj;
     }
 
+    private static class MyClassFactoryWrapper extends Ice.LocalObjectImpl implements Ice.ObjectFactory
+    {
+	MyClassFactoryWrapper()
+	{
+	    _factory = Test.MyClass.ice_factory();
+	}
+
+	public Ice.Object
+	create(String type)
+	{
+	    return _factory.create(type);
+	}
+
+	public void
+	destroy()
+	{
+	}
+
+	void
+	setFactory(Ice.ObjectFactory factory)
+	{
+	    _factory = factory;
+	}
+
+	private Ice.ObjectFactory _factory;
+    }
+
     private static int
     run(String[] args, Ice.Communicator communicator)
     {
+	MyClassFactoryWrapper factoryWrapper = new MyClassFactoryWrapper();
+	communicator.addObjectFactory(factoryWrapper, Test.MyClass.ice_staticId());
+
         Ice.InputStream in;
         Ice.OutputStream out;
 
@@ -426,7 +456,19 @@ public class Client
             out.writePendingObjects();
             byte[] data = out.finished();
             test(writer.called);
+            factoryWrapper.setFactory(new TestObjectFactory());
+            in = Ice.Util.createInputStream(communicator, data);
+            TestReadObjectCallback cb = new TestReadObjectCallback();
+            in.readObject(cb);
+            in.readPendingObjects();
+            test(cb.obj != null);
+            test(cb.obj instanceof TestObjectReader);
+            TestObjectReader reader = (TestObjectReader)cb.obj;
+            test(reader.called);
+            test(reader.obj != null);
+            test(reader.obj.s.e == Test.MyEnum.enum2);
             out.destroy();
+            in.destroy();
         }
 
         System.out.println("ok");