summaryrefslogtreecommitdiff
path: root/cpp/test/Ice/stream/Client.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'cpp/test/Ice/stream/Client.cpp')
-rw-r--r--cpp/test/Ice/stream/Client.cpp1020
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);
}
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-04 03:23:18 +0000