minor fixes to stream classes; restoring test/Ice/stream

1 files changed, 572 insertions, 448 deletions

diff --git a/cpp/test/Ice/stream/Client.cpp b/cpp/test/Ice/stream/Client.cpp
index f09293e7092..a0302b47d46 100644
--- a/cpp/test/Ice/stream/Client.cpp
+++ b/cpp/test/Ice/stream/Client.cpp
@@ -14,30 +14,45 @@
 DEFINE_TEST("client")
 
 using namespace std;
+using namespace Test;
+using namespace Test::Sub;
+using namespace Test2::Sub2;
 
-class TestObjectWriter : public Ice::ObjectWriter
+#ifdef ICE_CPP11_MAPPING
+class TestObjectWriter : public Ice::ValueHelper<TestObjectWriter, Ice::Value>
+#else
+class TestObjectWriter : public Ice::Object
+#endif
 {
 public:
 
-    TestObjectWriter(const Test::MyClassPtr& p)
+    TestObjectWriter(const MyClassPtr& p)
     {
         obj = p;
         called = false;
     }
 
-    virtual void
-    write(const Ice::OutputStreamPtr& out) const
+    virtual void __write(Ice::OutputStream* out) const
     {
         obj->__write(out);
         const_cast<TestObjectWriter*>(this)->called = true;
     }
 
-    Test::MyClassPtr obj;
+    virtual void __read(Ice::InputStream*)
+    {
+        assert(false);
+    }
+
+    MyClassPtr obj;
     bool called;
 };
-typedef IceUtil::Handle<TestObjectWriter> TestObjectWriterPtr;
+ICE_DEFINE_PTR(TestObjectWriterPtr, TestObjectWriter);
 
-class TestObjectReader : public Ice::ObjectReader
+#ifdef ICE_CPP11_MAPPING
+class TestObjectReader : public Ice::ValueHelper<TestObjectReader, Ice::Value>
+#else
+class TestObjectReader : public Ice::Object
+#endif
 {
 public:
 
@@ -46,19 +61,24 @@ public:
         called = false;
     }
 
-    virtual void
-    read(const Ice::InputStreamPtr& in)
+    virtual void __write(Ice::OutputStream*) const
+    {
+        assert(false);
+    }
+
+    virtual void __read(Ice::InputStream* in)
     {
-        obj = new Test::MyClass;
+        obj = ICE_MAKE_SHARED(MyClass);
         obj->__read(in);
         called = true;
     }
 
-    Test::MyClassPtr obj;
+    MyClassPtr obj;
     bool called;
 };
-typedef IceUtil::Handle<TestObjectReader> TestObjectReaderPtr;
+ICE_DEFINE_PTR(TestObjectReaderPtr, TestObjectReader);
 
+#ifndef ICE_CPP11_MAPPING
 class TestValueFactory : public Ice::ValueFactory
 {
 public:
@@ -70,7 +90,7 @@ public:
     create(const string&)
 #endif
     {
-        assert(type == Test::MyClass::ice_staticId());
+        assert(type == MyClass::ice_staticId());
         return new TestObjectReader;
     }
 
@@ -79,51 +99,80 @@ public:
     {
     }
 };
+#endif
+
+#ifdef ICE_CPP11_MAPPING
+void
+patchObject(void* addr, const Ice::ValuePtr& v)
+{   
+    Ice::ValuePtr* p = static_cast<Ice::ValuePtr*>(addr);
+    assert(p);
+    *p = v;
+}
+#else
+void
+patchObject(void* addr, const Ice::ObjectPtr& v)
+{   
+    Ice::ObjectPtr* p = static_cast<Ice::ObjectPtr*>(addr);
+    assert(p);
+    *p = v;
+}
+#endif
 
-class TestReadObjectCallback : public Ice::ReadObjectCallback
+#ifdef ICE_CPP11_MAPPING
+class MyClassFactoryWrapper
 {
 public:
 
-    virtual void
-    invoke(const Ice::ObjectPtr& p)
+    MyClassFactoryWrapper()
     {
-        obj = p;
+        clear();
     }
 
-    Ice::ObjectPtr obj;
-};
-typedef IceUtil::Handle<TestReadObjectCallback> TestReadObjectCallbackPtr;
+    Ice::ValuePtr create(const string& type)
+    {
+        return _factory(type);
+    }
+
+    void setFactory(function<Ice::ValuePtr (const string&)> f)
+    {
+        _factory = f;
+    }
 
+    void clear()
+    {
+        _factory = [](const string&) { return ICE_MAKE_SHARED(MyClass); };
+    }
+
+    function<Ice::ValuePtr (const string&)> _factory;
+};
+#else
 class MyClassFactoryWrapper : public Ice::ValueFactory
 {
 public:
 
-    MyClassFactoryWrapper() : _factory(Test::MyClass::ice_factory())
+    MyClassFactoryWrapper()
     {
+        clear();
     }
 
-    virtual Ice::ObjectPtr
-    create(const string& type)
+    virtual Ice::ObjectPtr create(const string& type)
     {
         return _factory->create(type);
     }
 
-    virtual void
-    destroy()
+    virtual void destroy()
     {
     }
 
-    void
-    setFactory(const Ice::ValueFactoryPtr& factory)
+    void setFactory(const Ice::ValueFactoryPtr& factory)
     {
-        if(!factory)
-        {
-            _factory = Test::MyClass::ice_factory();
-        }
-        else
-        {
-            _factory = factory;
-        }
+        _factory = factory;
+    }
+
+    void clear()
+    {
+        _factory = MyClass::ice_factory();
     }
 
 private:
@@ -131,7 +180,9 @@ private:
     Ice::ValueFactoryPtr _factory;
 };
 typedef IceUtil::Handle<MyClassFactoryWrapper> MyClassFactoryWrapperPtr;
+#endif
 
+#ifndef ICE_CPP11_MAPPING
 class MyInterfaceFactory : public Ice::ValueFactory
 {
 public:
@@ -139,7 +190,7 @@ public:
     virtual Ice::ObjectPtr
     create(const string&)
     {
-        return new Test::MyInterface;
+        return new MyInterface;
     }
 
     virtual void
@@ -147,60 +198,59 @@ public:
     {
     }
 };
+#endif
 
 int
 run(int, char**, const Ice::CommunicatorPtr& communicator)
 {
+#ifdef ICE_CPP11_MAPPING
+    MyClassFactoryWrapper factoryWrapper;
+    function<Ice::ValuePtr (const string&)> f =
+        std::bind(&MyClassFactoryWrapper::create, &factoryWrapper, std::placeholders::_1);
+    communicator->getValueFactoryManager()->add(f, MyClass::ice_staticId());
+#else
     MyClassFactoryWrapperPtr factoryWrapper = new MyClassFactoryWrapper;
-    communicator->addValueFactory(factoryWrapper, Test::MyClass::ice_staticId());
-    communicator->addValueFactory(new MyInterfaceFactory, Test::MyInterface::ice_staticId());
+    communicator->getValueFactoryManager()->add(factoryWrapper, MyClass::ice_staticId());
+    communicator->getValueFactoryManager()->add(new MyInterfaceFactory, MyInterface::ice_staticId());
+#endif
 
-    Ice::InputStreamPtr in;
-    Ice::OutputStreamPtr out;
     vector<Ice::Byte> data;
 
     //
-    // Test the stream api.
+    // Test the stream API.
     //
     cout << "testing primitive types... " << flush;
 
     {
         vector<Ice::Byte> byte;
-        in = Ice::createInputStream(communicator, byte);
+        Ice::InputStream in(communicator, byte);
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        out->startEncapsulation();
-        out->write(true);
-        out->endEncapsulation();
-        out->finished(data);
-        pair<const Ice::Byte*, const Ice::Byte*> d = out->finished();
+        Ice::OutputStream out(communicator);
+        out.startEncapsulation();
+        out.write(true);
+        out.endEncapsulation();
+        out.finished(data);
+        pair<const Ice::Byte*, const Ice::Byte*> d = out.finished();
         test(d.second - d.first == static_cast<int>(data.size()));
         test(vector<Ice::Byte>(d.first, d.second) == data);
-        out = 0;
 
-        in = Ice::createInputStream(communicator, data);
-        in->startEncapsulation();
+        Ice::InputStream in(communicator, data);
+        in.startEncapsulation();
         bool v;
-        in->read(v);
-        test(v);
-        in->endEncapsulation();
-
-        in = Ice::wrapInputStream(communicator, data);
-        in->startEncapsulation();
-        in->read(v);
+        in.read(v);
         test(v);
-        in->endEncapsulation();
+        in.endEncapsulation();
     }
 
     {
         vector<Ice::Byte> byte;
-        in = Ice::createInputStream(communicator, byte);
+        Ice::InputStream in(communicator, byte);
         try
         {
             bool v;
-            in->read(v);
+            in.read(v);
             test(false);
         }
         catch(const Ice::UnmarshalOutOfBoundsException&)
@@ -209,82 +259,82 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        out->write(true);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write(true);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         bool v;
-        in->read(v);
+        in.read(v);
         test(v);
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        out->write((Ice::Byte)1);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write((Ice::Byte)1);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         Ice::Byte v;
-        in->read(v);
+        in.read(v);
         test(v == 1);
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        out->write((Ice::Short)2);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write((Ice::Short)2);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         Ice::Short v;
-        in->read(v);
+        in.read(v);
         test(v == 2);
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        out->write((Ice::Int)3);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write((Ice::Int)3);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         Ice::Int v;
-        in->read(v);
+        in.read(v);
         test(v == 3);
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        out->write((Ice::Long)4);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write((Ice::Long)4);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         Ice::Long v;
-        in->read(v);
+        in.read(v);
         test(v == 4);
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        out->write((Ice::Float)5.0);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write((Ice::Float)5.0);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         Ice::Float v;
-        in->read(v);
+        in.read(v);
         test(v == 5.0);
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        out->write((Ice::Double)6.0);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write((Ice::Double)6.0);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         Ice::Double v;
-        in->read(v);
+        in.read(v);
         test(v == 6.0);
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        out->write("hello world");
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write("hello world");
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         string v;
-        in->read(v);
+        in.read(v);
         test(v == "hello world");
     }
 
@@ -293,18 +343,18 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
     cout << "testing constructed types... " << flush;
 
     {
-        out = Ice::createOutputStream(communicator);
-        out->write(Test::enum3);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::MyEnum e;
-        in->read(e);
-        test(e == Test::enum3);
+        Ice::OutputStream out(communicator);
+        out.write(ICE_ENUM(MyEnum, enum3));
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        MyEnum e;
+        in.read(e);
+        test(e == ICE_ENUM(MyEnum, enum3));
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        Test::SmallStruct s;
+        Ice::OutputStream out(communicator);
+        SmallStruct s;
         s.bo = true;
         s.by = 1;
         s.sh = 2;
@@ -313,45 +363,52 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
         s.f = 5.0;
         s.d = 6.0;
         s.str = "7";
-        s.e = Test::enum2;
-        s.p = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy("test:default"));
-        out->write(s);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::SmallStruct s2;
-        in->read(s2);
+        s.e = ICE_ENUM(MyEnum, enum2);
+        s.p = ICE_UNCHECKED_CAST(MyInterfacePrx, communicator->stringToProxy("test:default"));
+        out.write(s);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        SmallStruct s2;
+        in.read(s2);
+#ifndef ICE_CPP11_MAPPING
+        //
+        // No comparison operator generated in C++11.
+        //
         test(s2 == s);
+#endif
     }
 
+#ifndef ICE_CPP11_MAPPING
     {
-        out = Ice::createOutputStream(communicator);
-        Test::ClassStructPtr s = new Test::ClassStruct();
+        Ice::OutputStream out(communicator);
+        ClassStructPtr s = new ClassStruct();
         s->i = 10;
-        out->write(s);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::ClassStructPtr s2 = new Test::ClassStruct();
-        in->read(s2);
+        out.write(s);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        ClassStructPtr s2 = new ClassStruct();
+        in.read(s2);
         test(s2->i == s->i);
     }
+#endif
 
     {
-        out = Ice::createOutputStream(communicator);
-        Test::OptionalClassPtr o = new Test::OptionalClass();
+        Ice::OutputStream out(communicator);
+        OptionalClassPtr o = ICE_MAKE_SHARED(OptionalClass);
         o->bo = false;
         o->by = 5;
         o->sh = 4;
         o->i = 3;
-        out->write(o);
-        out->writePendingObjects();
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::OptionalClassPtr o2;
-        in->read(o2);
-        in->readPendingObjects();
+        out.write(o);
+        out.writePendingObjects();
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        OptionalClassPtr o2;
+        in.read(o2);
+        in.readPendingObjects();
         test(o2->bo == o->bo);
         test(o2->by == o->by);
-        if(in->getEncoding() == Ice::Encoding_1_0)
+        if(in.getEncoding() == Ice::Encoding_1_0)
         {
             test(!o2->sh);
             test(!o2->i);
@@ -364,19 +421,19 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
     }
 
     {
-        out = Ice::createOutputStream(communicator, Ice::Encoding_1_0);
-        Test::OptionalClassPtr o = new Test::OptionalClass();
+        Ice::OutputStream out(communicator, Ice::Encoding_1_0);
+        OptionalClassPtr o = ICE_MAKE_SHARED(OptionalClass);
         o->bo = false;
         o->by = 5;
         o->sh = 4;
         o->i = 3;
-        out->write(o);
-        out->writePendingObjects();
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data, Ice::Encoding_1_0);
-        Test::OptionalClassPtr o2;
-        in->read(o2);
-        in->readPendingObjects();
+        out.write(o);
+        out.writePendingObjects();
+        out.finished(data);
+        Ice::InputStream in(communicator, Ice::Encoding_1_0, data);
+        OptionalClassPtr o2;
+        in.read(o2);
+        in.readPendingObjects();
         test(o2->bo == o->bo);
         test(o2->by == o->by);
         test(!o2->sh);
@@ -390,27 +447,27 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
         arr.push_back(true);
         arr.push_back(false);
 
-        out = Ice::createOutputStream(communicator);
-        out->write(arr);
-        out->finished(data);
+        Ice::OutputStream out(communicator);
+        out.write(arr);
+        out.finished(data);
 
-        in = Ice::createInputStream(communicator, data);
+        Ice::InputStream in(communicator, data);
         Ice::BoolSeq arr2;
-        in->read(arr2);
+        in.read(arr2);
         test(arr2 == arr);
 
-        Test::BoolSS arrS;
+        BoolSS arrS;
         arrS.push_back(arr);
         arrS.push_back(Ice::BoolSeq());
         arrS.push_back(arr);
 
-        out = Ice::createOutputStream(communicator);
-        out->write(arrS);
-        out->finished(data);
+        Ice::OutputStream out2(communicator);
+        out2.write(arrS);
+        out2.finished(data);
 
-        in = Ice::createInputStream(communicator, data);
-        Test::BoolSS arr2S;
-        in->read(arr2S);
+        Ice::InputStream in2(communicator, data);
+        BoolSS arr2S;
+        in2.read(arr2S);
         test(arr2S == arrS);
     }
 
@@ -421,26 +478,26 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
         arr.push_back(0x12);
         arr.push_back(0x22);
 
-        out = Ice::createOutputStream(communicator);
-        out->write(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write(arr);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         Ice::ByteSeq arr2;
-        in->read(arr2);
+        in.read(arr2);
         test(arr2 == arr);
 
-        Test::ByteSS arrS;
+        ByteSS arrS;
         arrS.push_back(arr);
         arrS.push_back(Ice::ByteSeq());
         arrS.push_back(arr);
 
-        out = Ice::createOutputStream(communicator);
-        out->write(arrS);
-        out->finished(data);
+        Ice::OutputStream out2(communicator);
+        out2.write(arrS);
+        out2.finished(data);
 
-        in = Ice::createInputStream(communicator, data);
-        Test::ByteSS arr2S;
-        in->read(arr2S);
+        Ice::InputStream in2(communicator, data);
+        ByteSS arr2S;
+        in2.read(arr2S);
         test(arr2S == arrS);
     }
 
@@ -450,26 +507,26 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
         arr.push_back(0x11);
         arr.push_back(0x12);
         arr.push_back(0x22);
-        out = Ice::createOutputStream(communicator);
-        out->write(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write(arr);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         Ice::ShortSeq arr2;
-        in->read(arr2);
+        in.read(arr2);
         test(arr2 == arr);
 
-        Test::ShortSS arrS;
+        ShortSS arrS;
         arrS.push_back(arr);
         arrS.push_back(Ice::ShortSeq());
         arrS.push_back(arr);
 
-        out = Ice::createOutputStream(communicator);
-        out->write(arrS);
-        out->finished(data);
+        Ice::OutputStream out2(communicator);
+        out2.write(arrS);
+        out2.finished(data);
 
-        in = Ice::createInputStream(communicator, data);
-        Test::ShortSS arr2S;
-        in->read(arr2S);
+        Ice::InputStream in2(communicator, data);
+        ShortSS arr2S;
+        in2.read(arr2S);
         test(arr2S == arrS);
     }
 
@@ -479,26 +536,26 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
         arr.push_back(0x11);
         arr.push_back(0x12);
         arr.push_back(0x22);
-        out = Ice::createOutputStream(communicator);
-        out->write(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write(arr);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         Ice::IntSeq arr2;
-        in->read(arr2);
+        in.read(arr2);
         test(arr2 == arr);
 
-        Test::IntSS arrS;
+        IntSS arrS;
         arrS.push_back(arr);
         arrS.push_back(Ice::IntSeq());
         arrS.push_back(arr);
 
-        out = Ice::createOutputStream(communicator);
-        out->write(arrS);
-        out->finished(data);
+        Ice::OutputStream out2(communicator);
+        out2.write(arrS);
+        out2.finished(data);
 
-        in = Ice::createInputStream(communicator, data);
-        Test::IntSS arr2S;
-        in->read(arr2S);
+        Ice::InputStream in2(communicator, data);
+        IntSS arr2S;
+        in2.read(arr2S);
         test(arr2S == arrS);
     }
 
@@ -508,26 +565,26 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
         arr.push_back(0x11);
         arr.push_back(0x12);
         arr.push_back(0x22);
-        out = Ice::createOutputStream(communicator);
-        out->write(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write(arr);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         Ice::LongSeq arr2;
-        in->read(arr2);
+        in.read(arr2);
         test(arr2 == arr);
 
-        Test::LongSS arrS;
+        LongSS arrS;
         arrS.push_back(arr);
         arrS.push_back(Ice::LongSeq());
         arrS.push_back(arr);
 
-        out = Ice::createOutputStream(communicator);
-        out->write(arrS);
-        out->finished(data);
+        Ice::OutputStream out2(communicator);
+        out2.write(arrS);
+        out2.finished(data);
 
-        in = Ice::createInputStream(communicator, data);
-        Test::LongSS arr2S;
-        in->read(arr2S);
+        Ice::InputStream in2(communicator, data);
+        LongSS arr2S;
+        in2.read(arr2S);
         test(arr2S == arrS);
     }
 
@@ -537,26 +594,26 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
         arr.push_back(2);
         arr.push_back(3);
         arr.push_back(4);
-        out = Ice::createOutputStream(communicator);
-        out->write(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write(arr);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         Ice::FloatSeq arr2;
-        in->read(arr2);
+        in.read(arr2);
         test(arr2 == arr);
 
-        Test::FloatSS arrS;
+        FloatSS arrS;
         arrS.push_back(arr);
         arrS.push_back(Ice::FloatSeq());
         arrS.push_back(arr);
 
-        out = Ice::createOutputStream(communicator);
-        out->write(arrS);
-        out->finished(data);
+        Ice::OutputStream out2(communicator);
+        out2.write(arrS);
+        out2.finished(data);
 
-        in = Ice::createInputStream(communicator, data);
-        Test::FloatSS arr2S;
-        in->read(arr2S);
+        Ice::InputStream in2(communicator, data);
+        FloatSS arr2S;
+        in2.read(arr2S);
         test(arr2S == arrS);
     }
 
@@ -566,26 +623,26 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
         arr.push_back(2);
         arr.push_back(3);
         arr.push_back(4);
-        out = Ice::createOutputStream(communicator);
-        out->write(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write(arr);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         Ice::DoubleSeq arr2;
-        in->read(arr2);
+        in.read(arr2);
         test(arr2 == arr);
 
-        Test::DoubleSS arrS;
+        DoubleSS arrS;
         arrS.push_back(arr);
         arrS.push_back(Ice::DoubleSeq());
         arrS.push_back(arr);
 
-        out = Ice::createOutputStream(communicator);
-        out->write(arrS);
-        out->finished(data);
+        Ice::OutputStream out2(communicator);
+        out2.write(arrS);
+        out2.finished(data);
 
-        in = Ice::createInputStream(communicator, data);
-        Test::DoubleSS arr2S;
-        in->read(arr2S);
+        Ice::InputStream in2(communicator, data);
+        DoubleSS arr2S;
+        in2.read(arr2S);
         test(arr2S == arrS);
     }
 
@@ -595,64 +652,64 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
         arr.push_back("string2");
         arr.push_back("string3");
         arr.push_back("string4");
-        out = Ice::createOutputStream(communicator);
-        out->write(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        Ice::OutputStream out(communicator);
+        out.write(arr);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         Ice::StringSeq arr2;
-        in->read(arr2);
+        in.read(arr2);
         test(arr2 == arr);
 
-        Test::StringSS arrS;
+        StringSS arrS;
         arrS.push_back(arr);
         arrS.push_back(Ice::StringSeq());
         arrS.push_back(arr);
 
-        out = Ice::createOutputStream(communicator);
-        out->write(arrS);
-        out->finished(data);
+        Ice::OutputStream out2(communicator);
+        out2.write(arrS);
+        out2.finished(data);
 
-        in = Ice::createInputStream(communicator, data);
-        Test::StringSS arr2S;
-        in->read(arr2S);
+        Ice::InputStream in2(communicator, data);
+        StringSS arr2S;
+        in2.read(arr2S);
         test(arr2S == arrS);
     }
 
     {
-        Test::MyEnumS arr;
-        arr.push_back(Test::enum3);
-        arr.push_back(Test::enum2);
-        arr.push_back(Test::enum1);
-        arr.push_back(Test::enum2);
-
-        out = Ice::createOutputStream(communicator);
-        out->write(arr);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::MyEnumS arr2;
-        in->read(arr2);
+        MyEnumS arr;
+        arr.push_back(ICE_ENUM(MyEnum, enum3));
+        arr.push_back(ICE_ENUM(MyEnum, enum2));
+        arr.push_back(ICE_ENUM(MyEnum, enum1));
+        arr.push_back(ICE_ENUM(MyEnum, enum2));
+
+        Ice::OutputStream out(communicator);
+        out.write(arr);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        MyEnumS arr2;
+        in.read(arr2);
         test(arr2 == arr);
 
-        Test::MyEnumSS arrS;
+        MyEnumSS arrS;
         arrS.push_back(arr);
-        arrS.push_back(Test::MyEnumS());
+        arrS.push_back(MyEnumS());
         arrS.push_back(arr);
 
-        out = Ice::createOutputStream(communicator);
-        out->write(arrS);
-        out->finished(data);
+        Ice::OutputStream out2(communicator);
+        out2.write(arrS);
+        out2.finished(data);
 
-        in = Ice::createInputStream(communicator, data);
-        Test::MyEnumSS arr2S;
-        in->read(arr2S);
+        Ice::InputStream in2(communicator, data);
+        MyEnumSS arr2S;
+        in2.read(arr2S);
         test(arr2S == arrS);
     }
 
     {
-        Test::SmallStructS arr;
+        SmallStructS arr;
         for(int i = 0; i < 4; ++i)
         {
-            Test::SmallStruct s;
+            SmallStruct s;
             s.bo = true;
             s.by = 1;
             s.sh = 2;
@@ -661,47 +718,57 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
             s.f = 5.0;
             s.d = 6.0;
             s.str = "7";
-            s.e = Test::enum2;
-            s.p = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy("test:default"));
+            s.e = ICE_ENUM(MyEnum, enum2);
+            s.p = ICE_UNCHECKED_CAST(MyInterfacePrx, communicator->stringToProxy("test:default"));
             arr.push_back(s);
         }
-        out = Ice::createOutputStream(communicator);
-        out->write(arr);
-        out->writePendingObjects();
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::SmallStructS arr2;
-        in->read(arr2);
-        in->readPendingObjects();
+        Ice::OutputStream out(communicator);
+        out.write(arr);
+        out.writePendingObjects();
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        SmallStructS arr2;
+        in.read(arr2);
+        in.readPendingObjects();
         test(arr2.size() == arr.size());
-        for(Test::SmallStructS::size_type j = 0; j < arr2.size(); ++j)
+#ifndef ICE_CPP11_MAPPING
+        //
+        // No comparison operator generated in C++11.
+        //
+        for(SmallStructS::size_type j = 0; j < arr2.size(); ++j)
         {
             test(arr[j] == arr2[j]);
         }
+#endif
 
-        Test::SmallStructSS arrS;
+        SmallStructSS arrS;
         arrS.push_back(arr);
-        arrS.push_back(Test::SmallStructS());
+        arrS.push_back(SmallStructS());
         arrS.push_back(arr);
 
-        out = Ice::createOutputStream(communicator);
-        out->write(arrS);
-        out->finished(data);
-
-        in = Ice::createInputStream(communicator, data);
-        Test::SmallStructSS arr2S;
-        in->read(arr2S);
+        Ice::OutputStream out2(communicator);
+        out2.write(arrS);
+        out2.finished(data);
+
+        Ice::InputStream in2(communicator, data);
+        SmallStructSS arr2S;
+        in2.read(arr2S);
+#ifndef ICE_CPP11_MAPPING
+        //
+        // No comparison operator generated in C++11.
+        //
         test(arr2S == arrS);
+#endif
     }
 
     {
-        Test::MyClassS arr;
+        MyClassS arr;
         for(int i = 0; i < 4; ++i)
         {
-            Test::MyClassPtr c = new Test::MyClass;
+            MyClassPtr c = ICE_MAKE_SHARED(MyClass);
             c->c = c;
             c->o = c;
-            c->s.e = Test::enum2;
+            c->s.e = ICE_ENUM(MyEnum, enum2);
 
             c->seq1.push_back(true);
             c->seq1.push_back(false);
@@ -743,29 +810,34 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
             c->seq8.push_back("string3");
             c->seq8.push_back("string4");
 
-            c->seq9.push_back(Test::enum3);
-            c->seq9.push_back(Test::enum2);
-            c->seq9.push_back(Test::enum1);
+            c->seq9.push_back(ICE_ENUM(MyEnum, enum3));
+            c->seq9.push_back(ICE_ENUM(MyEnum, enum2));
+            c->seq9.push_back(ICE_ENUM(MyEnum, enum1));
 
             c->d["hi"] = c;
+#ifndef ICE_CPP11_MAPPING
+            //
+            // No GC support in C++11.
+            //
             c->ice_collectable(true);
+#endif
             arr.push_back(c);
         }
-        out = Ice::createOutputStream(communicator);
-        out->write(arr);
-        out->writePendingObjects();
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::MyClassS arr2;
-        in->read(arr2);
-        in->readPendingObjects();
+        Ice::OutputStream out(communicator);
+        out.write(arr);
+        out.writePendingObjects();
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        MyClassS arr2;
+        in.read(arr2);
+        in.readPendingObjects();
         test(arr2.size() == arr.size());
-        for(Test::MyClassS::size_type j = 0; j < arr2.size(); ++j)
+        for(MyClassS::size_type j = 0; j < arr2.size(); ++j)
         {
             test(arr2[j]);
             test(arr2[j]->c == arr2[j]);
             test(arr2[j]->o == arr2[j]);
-            test(arr2[j]->s.e == Test::enum2);
+            test(arr2[j]->s.e == ICE_ENUM(MyEnum, enum2));
             test(arr2[j]->seq1 == arr[j]->seq1);
             test(arr2[j]->seq2 == arr[j]->seq2);
             test(arr2[j]->seq3 == arr[j]->seq3);
@@ -778,78 +850,105 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
             test(arr2[j]->d["hi"] == arr2[j]);
         }
 
-        Test::MyClassSS arrS;
+        MyClassSS arrS;
         arrS.push_back(arr);
-        arrS.push_back(Test::MyClassS());
+        arrS.push_back(MyClassS());
         arrS.push_back(arr);
 
-        out = Ice::createOutputStream(communicator);
-        out->write(arrS);
-        out->finished(data);
+        Ice::OutputStream out2(communicator);
+        out2.write(arrS);
+        out2.finished(data);
 
-        in = Ice::createInputStream(communicator, data);
-        Test::MyClassSS arr2S;
-        in->read(arr2S);
+        Ice::InputStream in2(communicator, data);
+        MyClassSS arr2S;
+        in2.read(arr2S);
         test(arr2S.size() == arrS.size());
         test(arr2S[0].size() == arrS[0].size());
         test(arr2S[1].size() == arrS[1].size());
         test(arr2S[2].size() == arrS[2].size());
     }
 
+#ifndef ICE_CPP11_MAPPING
+    //
+    // No support for interfaces-as-values in C++11.
+    //
     {
-        Test::MyInterfacePtr i = new Test::MyInterface();
-        out = Ice::createOutputStream(communicator);
-        out->write(i);
-        out->writePendingObjects();
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
+        MyInterfacePtr i = new MyInterface();
+        Ice::OutputStream out(communicator);
+        out.write(i);
+        out.writePendingObjects();
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
         i = 0;
-        in->read(i);
-        in->readPendingObjects();
+        in.read(i);
+        in.readPendingObjects();
         test(i);
     }
+#endif
 
     {
-        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);
+        Ice::OutputStream out(communicator);
+        MyClassPtr obj = ICE_MAKE_SHARED(MyClass);
+        obj->s.e = ICE_ENUM(MyEnum, enum2);
+        TestObjectWriterPtr writer = ICE_MAKE_SHARED(TestObjectWriter, obj);
+#ifdef ICE_CPP11_MAPPING
+        Ice::ValuePtr w = ICE_DYNAMIC_CAST(Ice::Value, writer);
+        out.write(w);
+#else
+        out.write(Ice::ObjectPtr(writer));
+#endif
+        out.writePendingObjects();
+        out.finished(data);
         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);
+        Ice::OutputStream out(communicator);
+        MyClassPtr obj = ICE_MAKE_SHARED(MyClass);
+        obj->s.e = ICE_ENUM(MyEnum, enum2);
+        TestObjectWriterPtr writer = ICE_MAKE_SHARED(TestObjectWriter, obj);
+#ifdef ICE_CPP11_MAPPING
+        Ice::ValuePtr w = ICE_DYNAMIC_CAST(Ice::Value, writer);
+        out.write(w);
+#else
+        out.write(Ice::ObjectPtr(writer));
+#endif
+        out.writePendingObjects();
+        out.finished(data);
         test(writer->called);
+#ifdef ICE_CPP11_MAPPING
+        factoryWrapper.setFactory([](const string&) { return ICE_MAKE_SHARED(TestObjectReader); });
+#else
         factoryWrapper->setFactory(new TestValueFactory);
-        in = Ice::createInputStream(communicator, data);
-        TestReadObjectCallbackPtr cb = new TestReadObjectCallback;
-        in->readObject(cb);
-        in->readPendingObjects();
-        test(cb->obj);
-        TestObjectReaderPtr reader = TestObjectReaderPtr::dynamicCast(cb->obj);
+#endif
+        Ice::InputStream in(communicator, data);
+#ifdef ICE_CPP11_MAPPING
+        Ice::ValuePtr p;
+#else
+        Ice::ObjectPtr p;
+#endif
+        in.read(&patchObject, &p);
+        in.readPendingObjects();
+        test(p);
+        TestObjectReaderPtr reader = ICE_DYNAMIC_CAST(TestObjectReader, p);
         test(reader);
         test(reader->called);
         test(reader->obj);
-        test(reader->obj->s.e == Test::enum2);
-        factoryWrapper->setFactory(0);
+        test(reader->obj->s.e == ICE_ENUM(MyEnum, enum2));
+#ifdef ICE_CPP11_MAPPING
+        factoryWrapper.clear();
+#else
+        factoryWrapper->clear();
+#endif
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        Test::MyException ex;
-        Test::MyClassPtr c = new Test::MyClass;
+        Ice::OutputStream out(communicator);
+        MyException ex;
+        MyClassPtr c = ICE_MAKE_SHARED(MyClass);
         c->c = c;
         c->o = c;
-        c->s.e = Test::enum2;
+        c->s.e = ICE_ENUM(MyEnum, enum2);
 
         c->seq1.push_back(true);
         c->seq1.push_back(false);
@@ -891,23 +990,28 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
         c->seq8.push_back("string3");
         c->seq8.push_back("string4");
 
-        c->seq9.push_back(Test::enum3);
-        c->seq9.push_back(Test::enum2);
-        c->seq9.push_back(Test::enum1);
+        c->seq9.push_back(ICE_ENUM(MyEnum, enum3));
+        c->seq9.push_back(ICE_ENUM(MyEnum, enum2));
+        c->seq9.push_back(ICE_ENUM(MyEnum, enum1));
 
         ex.c = c;
+#ifndef ICE_CPP11_MAPPING
+        //
+        // No GC support in C++11.
+        //
         ex.c->ice_collectable(true);
+#endif
 
-        out->write(ex);
-        out->finished(data);
+        out.write(ex);
+        out.finished(data);
 
-        in = Ice::createInputStream(communicator, data);
+        Ice::InputStream in(communicator, data);
         try
         {
-            in->throwException();
+            in.throwException();
             test(false);
         }
-        catch(const Test::MyException& ex1)
+        catch(const MyException& ex1)
         {
             test(ex1.c->s.e == c->s.e);
             test(ex1.c->seq1 == c->seq1);
@@ -923,89 +1027,89 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
     }
 
     {
-        Test::ByteBoolD dict;
+        ByteBoolD dict;
         dict[0x04] = true;
         dict[0x01] = false;
-        out = Ice::createOutputStream(communicator);
-        out->write(dict);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::ByteBoolD dict2;
-        in->read(dict2);
+        Ice::OutputStream out(communicator);
+        out.write(dict);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        ByteBoolD dict2;
+        in.read(dict2);
         test(dict2 == dict);
     }
 
     {
-        Test::ShortIntD dict;
+        ShortIntD dict;
         dict[1] = 9;
         dict[4] = 8;
-        out = Ice::createOutputStream(communicator);
-        out->write(dict);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::ShortIntD dict2;
-        in->read(dict2);
+        Ice::OutputStream out(communicator);
+        out.write(dict);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        ShortIntD dict2;
+        in.read(dict2);
         test(dict2 == dict);
     }
 
     {
-        Test::LongFloatD dict;
+        LongFloatD dict;
         dict[123809828] = 0.51f;
         dict[123809829] = 0.56f;
-        out = Ice::createOutputStream(communicator);
-        out->write(dict);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::LongFloatD dict2;
-        in->read(dict2);
+        Ice::OutputStream out(communicator);
+        out.write(dict);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        LongFloatD dict2;
+        in.read(dict2);
         test(dict2 == dict);
     }
 
     {
-        Test::StringStringD dict;
+        StringStringD dict;
         dict["key1"] = "value1";
         dict["key2"] = "value2";
-        out = Ice::createOutputStream(communicator);
-        out->write(dict);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::StringStringD dict2;
-        in->read(dict2);
+        Ice::OutputStream out(communicator);
+        out.write(dict);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        StringStringD dict2;
+        in.read(dict2);
         test(dict2 == dict);
     }
 
     {
-        Test::StringMyClassD dict;
-        dict["key1"] = new Test::MyClass;
-        dict["key1"]->s.e = Test::enum2;
-        dict["key2"] = new Test::MyClass;
-        dict["key2"]->s.e = Test::enum3;
-        out = Ice::createOutputStream(communicator);
-        out->write(dict);
-        out->writePendingObjects();
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::StringMyClassD dict2;
-        in->read(dict2);
-        in->readPendingObjects();
+        StringMyClassD dict;
+        dict["key1"] = ICE_MAKE_SHARED(MyClass);
+        dict["key1"]->s.e = ICE_ENUM(MyEnum, enum2);
+        dict["key2"] = ICE_MAKE_SHARED(MyClass);
+        dict["key2"]->s.e = ICE_ENUM(MyEnum, enum3);
+        Ice::OutputStream out(communicator);
+        out.write(dict);
+        out.writePendingObjects();
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        StringMyClassD dict2;
+        in.read(dict2);
+        in.readPendingObjects();
         test(dict2.size() == dict.size());
-        test(dict2["key1"] && (dict2["key1"]->s.e == Test::enum2));
-        test(dict2["key2"] && (dict2["key2"]->s.e == Test::enum3));
+        test(dict2["key1"] && (dict2["key1"]->s.e == ICE_ENUM(MyEnum, enum2)));
+        test(dict2["key2"] && (dict2["key2"]->s.e == ICE_ENUM(MyEnum, enum3)));
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        out->write(Test::Sub::nestedEnum3);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::Sub::NestedEnum e;
-        in->read(e);
-        test(e == Test::Sub::nestedEnum3);
+        Ice::OutputStream out(communicator);
+        out.write(ICE_ENUM(Sub::NestedEnum, nestedEnum3));
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        NestedEnum e;
+        in.read(e);
+        test(e == ICE_ENUM(Sub::NestedEnum, nestedEnum3));
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        Test::Sub::NestedStruct s;
+        Ice::OutputStream out(communicator);
+        NestedStruct s;
         s.bo = true;
         s.by = 1;
         s.sh = 2;
@@ -1014,60 +1118,70 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
         s.f = 5.0;
         s.d = 6.0;
         s.str = "7";
-        s.e = Test::Sub::nestedEnum2;
-        out->write(s);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::Sub::NestedStruct s2;
-        in->read(s2);
+        s.e = ICE_ENUM(Sub::NestedEnum, nestedEnum2);
+        out.write(s);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        NestedStruct s2;
+        in.read(s2);
+#ifndef ICE_CPP11_MAPPING
+        //
+        // No comparison operator generated in C++11.
+        //
         test(s2 == s);
+#endif
     }
 
+#ifndef ICE_CPP11_MAPPING
+    //
+    // No support for struct-as-class in C++11.
+    //
     {
-        out = Ice::createOutputStream(communicator);
-        Test::Sub::NestedClassStructPtr s = new Test::Sub::NestedClassStruct();
+        Ice::OutputStream out(communicator);
+        NestedClassStructPtr s = new NestedClassStruct();
         s->i = 10;
-        out->write(s);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test::Sub::NestedClassStructPtr s2 = new Test::Sub::NestedClassStruct();
-        in->read(s2);
+        out.write(s);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        NestedClassStructPtr s2 = new NestedClassStruct();
+        in.read(s2);
         test(s2->i == s->i);
     }
+#endif
 
     {
-        out = Ice::createOutputStream(communicator);
-        Test::Sub::NestedException ex;
+        Ice::OutputStream out(communicator);
+        NestedException ex;
         ex.str = "str";
 
-        out->write(ex);
-        out->finished(data);
+        out.write(ex);
+        out.finished(data);
 
-        in = Ice::createInputStream(communicator, data);
+        Ice::InputStream in(communicator, data);
         try
         {
-            in->throwException();
+            in.throwException();
             test(false);
         }
-        catch(const Test::Sub::NestedException& ex1)
+        catch(const NestedException& ex1)
         {
             test(ex1.str == ex.str);
         }
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        out->write(Test2::Sub2::nestedEnum4);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test2::Sub2::NestedEnum2 e;
-        in->read(e);
-        test(e == Test2::Sub2::nestedEnum4);
+        Ice::OutputStream out(communicator);
+        out.write(ICE_ENUM(NestedEnum2, nestedEnum4));
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        NestedEnum2 e;
+        in.read(e);
+        test(e == ICE_ENUM(NestedEnum2, nestedEnum4));
     }
 
     {
-        out = Ice::createOutputStream(communicator);
-        Test2::Sub2::NestedStruct2 s;
+        Ice::OutputStream out(communicator);
+        NestedStruct2 s;
         s.bo = true;
         s.by = 1;
         s.sh = 2;
@@ -1076,42 +1190,52 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
         s.f = 5.0;
         s.d = 6.0;
         s.str = "7";
-        s.e = Test2::Sub2::nestedEnum5;
-        out->write(s);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test2::Sub2::NestedStruct2 s2;
-        in->read(s2);
+        s.e = ICE_ENUM(NestedEnum2, nestedEnum5);
+        out.write(s);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        NestedStruct2 s2;
+        in.read(s2);
+#ifndef ICE_CPP11_MAPPING
+        //
+        // No comparison operator generated in C++11.
+        //
         test(s2 == s);
+#endif
     }
 
+#ifndef ICE_CPP11_MAPPING
+    //
+    // No support for struct-as-class in C++11.
+    //
     {
-        out = Ice::createOutputStream(communicator);
-        Test2::Sub2::NestedClassStruct2Ptr s = new Test2::Sub2::NestedClassStruct2();
+        Ice::OutputStream out(communicator);
+        NestedClassStruct2Ptr s = new NestedClassStruct2();
         s->i = 10;
-        out->write(s);
-        out->finished(data);
-        in = Ice::createInputStream(communicator, data);
-        Test2::Sub2::NestedClassStruct2Ptr s2 = new Test2::Sub2::NestedClassStruct2();
-        in->read(s2);
+        out.write(s);
+        out.finished(data);
+        Ice::InputStream in(communicator, data);
+        NestedClassStruct2Ptr s2 = new NestedClassStruct2();
+        in.read(s2);
         test(s2->i == s->i);
     }
+#endif
 
     {
-        out = Ice::createOutputStream(communicator);
-        Test2::Sub2::NestedException2 ex;
+        Ice::OutputStream out(communicator);
+        NestedException2 ex;
         ex.str = "str";
 
-        out->write(ex);
-        out->finished(data);
+        out.write(ex);
+        out.finished(data);
 
-        in = Ice::createInputStream(communicator, data);
+        Ice::InputStream in(communicator, data);
         try
         {
-            in->throwException();
+            in.throwException();
             test(false);
         }
-        catch(const Test2::Sub2::NestedException2& ex1)
+        catch(const NestedException2& ex1)
         {
             test(ex1.str == ex.str);
         }