twowaysami.cpp

ICE-3.2 一个开源的中间件

        AMI_MyClass_opStringIPtr cb = new AMI_MyClass_opStringI;
        p->opString_async(cb, "hello", "world");
        test(cb->check());
    }

    {
        AMI_MyClass_opMyEnumIPtr cb = new AMI_MyClass_opMyEnumI;
        p->opMyEnum_async(cb, Test::enum2);
        test(cb->check());
    }

    {
        AMI_MyClass_opMyClassIPtr cb = new AMI_MyClass_opMyClassI(communicator);
        p->opMyClass_async(cb, p);
        test(cb->check());
    }

    {
        Test::Structure si1;
        si1.p = p;
        si1.e = Test::enum3;
        si1.s.s = "abc";
        Test::Structure si2;
        si2.p = 0;
        si2.e = Test::enum2;
        si2.s.s = "def";
        
        AMI_MyClass_opStructIPtr cb = new AMI_MyClass_opStructI(communicator);
        p->opStruct_async(cb, si1, si2);
        test(cb->check());
    }

    {
        Test::ByteS bsi1;
        Test::ByteS bsi2;

        bsi1.push_back(Ice::Byte(0x01));
        bsi1.push_back(Ice::Byte(0x11));
        bsi1.push_back(Ice::Byte(0x12));
        bsi1.push_back(Ice::Byte(0x22));

        bsi2.push_back(Ice::Byte(0xf1));
        bsi2.push_back(Ice::Byte(0xf2));
        bsi2.push_back(Ice::Byte(0xf3));
        bsi2.push_back(Ice::Byte(0xf4));

        AMI_MyClass_opByteSIPtr cb = new AMI_MyClass_opByteSI;
        p->opByteS_async(cb, bsi1, bsi2);
        test(cb->check());
    }

    {
        Test::BoolS bsi1;
        Test::BoolS bsi2;

        bsi1.push_back(true);
        bsi1.push_back(true);
        bsi1.push_back(false);

        bsi2.push_back(false);

        AMI_MyClass_opBoolSIPtr cb = new AMI_MyClass_opBoolSI;
        p->opBoolS_async(cb, bsi1, bsi2);
        test(cb->check());
    }

    {
        Test::ShortS ssi;
        Test::IntS isi;
        Test::LongS lsi;

        ssi.push_back(1);
        ssi.push_back(2);
        ssi.push_back(3);

        isi.push_back(5);
        isi.push_back(6);
        isi.push_back(7);
        isi.push_back(8);

        lsi.push_back(10);
        lsi.push_back(30);
        lsi.push_back(20);

        AMI_MyClass_opShortIntLongSIPtr cb = new AMI_MyClass_opShortIntLongSI;
        p->opShortIntLongS_async(cb, ssi, isi, lsi);
        test(cb->check());
    }

    {
        Test::FloatS fsi;
        Test::DoubleS dsi;

        fsi.push_back(Ice::Float(3.14));
        fsi.push_back(Ice::Float(1.11));

        dsi.push_back(Ice::Double(1.1E10));
        dsi.push_back(Ice::Double(1.2E10));
        dsi.push_back(Ice::Double(1.3E10));

        AMI_MyClass_opFloatDoubleSIPtr cb = new AMI_MyClass_opFloatDoubleSI;
        p->opFloatDoubleS_async(cb, fsi, dsi);
        test(cb->check());
    }

    {
        Test::StringS ssi1;
        Test::StringS ssi2;

        ssi1.push_back("abc");
        ssi1.push_back("de");
        ssi1.push_back("fghi");

        ssi2.push_back("xyz");

        AMI_MyClass_opStringSIPtr cb = new AMI_MyClass_opStringSI;
        p->opStringS_async(cb, ssi1, ssi2);
        test(cb->check());
    }

    {
        Test::ByteSS bsi1;
        bsi1.resize(2);
        Test::ByteSS bsi2;
        bsi2.resize(2);

        bsi1[0].push_back(Ice::Byte(0x01));
        bsi1[0].push_back(Ice::Byte(0x11));
        bsi1[0].push_back(Ice::Byte(0x12));
        bsi1[1].push_back(Ice::Byte(0xff));

        bsi2[0].push_back(Ice::Byte(0x0e));
        bsi2[1].push_back(Ice::Byte(0xf2));
        bsi2[1].push_back(Ice::Byte(0xf1));

        AMI_MyClass_opByteSSIPtr cb = new AMI_MyClass_opByteSSI;
        p->opByteSS_async(cb, bsi1, bsi2);
        test(cb->check());
    }

    {
        Test::FloatSS fsi;
        fsi.resize(3);
        Test::DoubleSS dsi;
        dsi.resize(1);

        fsi[0].push_back(Ice::Float(3.14));
        fsi[1].push_back(Ice::Float(1.11));

        dsi[0].push_back(Ice::Double(1.1E10));
        dsi[0].push_back(Ice::Double(1.2E10));
        dsi[0].push_back(Ice::Double(1.3E10));

        AMI_MyClass_opFloatDoubleSSIPtr cb = new AMI_MyClass_opFloatDoubleSSI;
        p->opFloatDoubleSS_async(cb, fsi, dsi);
        test(cb->check());
    }

    {
        Test::StringSS ssi1;
        ssi1.resize(2);
        Test::StringSS ssi2;
        ssi2.resize(3);

        ssi1[0].push_back("abc");
        ssi1[1].push_back("de");
        ssi1[1].push_back("fghi");

        ssi2[2].push_back("xyz");

        AMI_MyClass_opStringSSIPtr cb = new AMI_MyClass_opStringSSI;
        p->opStringSS_async(cb, ssi1, ssi2);
        test(cb->check());
    }

    {
        Test::ByteBoolD di1;
        di1[10] = true;
        di1[100] = false;
        Test::ByteBoolD di2;
        di2[10] = true;
        di2[11] = false;
        di2[101] = true;

        AMI_MyClass_opByteBoolDIPtr cb = new AMI_MyClass_opByteBoolDI;
        p->opByteBoolD_async(cb, di1, di2);
        test(cb->check());
    }

    {
        Test::ShortIntD di1;
        di1[110] = -1;
        di1[1100] = 123123;
        Test::ShortIntD di2;
        di2[110] = -1;
        di2[111] = -100;
        di2[1101] = 0;

        AMI_MyClass_opShortIntDIPtr cb = new AMI_MyClass_opShortIntDI;
        p->opShortIntD_async(cb, di1, di2);
        test(cb->check());
    }

    {
        Test::LongFloatD di1;
        di1[999999110] = Ice::Float(-1.1);
        di1[999999111] = Ice::Float(123123.2);
        Test::LongFloatD di2;
        di2[999999110] = Ice::Float(-1.1);
        di2[999999120] = Ice::Float(-100.4);
        di2[999999130] = Ice::Float(0.5);

        AMI_MyClass_opLongFloatDIPtr cb = new AMI_MyClass_opLongFloatDI;
        p->opLongFloatD_async(cb, di1, di2);
        test(cb->check());
    }

    {
        Test::StringStringD di1;
        di1["foo"] = "abc -1.1";
        di1["bar"] = "abc 123123.2";
        Test::StringStringD di2;
        di2["foo"] = "abc -1.1";
        di2["FOO"] = "abc -100.4";
        di2["BAR"] = "abc 0.5";

        AMI_MyClass_opStringStringDIPtr cb = new AMI_MyClass_opStringStringDI;
        p->opStringStringD_async(cb, di1, di2);
        test(cb->check());
    }

    {
        Test::StringMyEnumD di1;
        di1["abc"] = Test::enum1;
        di1[""] = Test::enum2;
        Test::StringMyEnumD di2;
        di2["abc"] = Test::enum1;
        di2["qwerty"] = Test::enum3;
        di2["Hello!!"] = Test::enum2;

        AMI_MyClass_opStringMyEnumDIPtr cb = new AMI_MyClass_opStringMyEnumDI;
        p->opStringMyEnumD_async(cb, di1, di2);
        test(cb->check());
    }

    {
        const int lengths[] = { 0, 1, 2, 126, 127, 128, 129, 253, 254, 255, 256, 257, 1000 };

        for(int l = 0; l != sizeof(lengths) / sizeof(*lengths); ++l)
        {
            Test::IntS s;
            for(int i = 0; i < lengths[l]; ++i)
            {
                s.push_back(i);
            }
            AMI_MyClass_opIntSIPtr cb = new AMI_MyClass_opIntSI(lengths[l]);
            p->opIntS_async(cb, s);
            test(cb->check());
        }
    }

    {
        Test::StringStringD ctx;
        ctx["one"] = "ONE";
        ctx["two"] = "TWO";
        ctx["three"] = "THREE";
        {
            test(p->ice_getContext().empty());
            AMI_MyClass_opContextNotEqualIPtr cb = new AMI_MyClass_opContextNotEqualI(ctx);
            p->opContext_async(cb);
            test(cb->check());
        }
        {
            test(p->ice_getContext().empty());
            AMI_MyClass_opContextEqualIPtr cb = new AMI_MyClass_opContextEqualI(ctx);
            p->opContext_async(cb, ctx);
            test(cb->check());
        }
        Test::MyClassPrx p2 = Test::MyClassPrx::checkedCast(p->ice_context(ctx));
        test(p2->ice_getContext() == ctx);
        {
            AMI_MyClass_opContextEqualIPtr cb = new AMI_MyClass_opContextEqualI(ctx);
            p2->opContext_async(cb);
            test(cb->check());
        }
        {
            Test::MyClassPrx p2 = Test::MyClassPrx::checkedCast(p->ice_context(ctx));
            AMI_MyClass_opContextEqualIPtr cb = new AMI_MyClass_opContextEqualI(ctx);
            p2->opContext_async(cb, ctx);
            test(cb->check());
        }

        {
            //
            // Test that default context is obtained correctly from communicator.
            //
/* DEPRECATED
            Ice::Context dflt;
            dflt["a"] = "b";
            communicator->setDefaultContext(dflt);
            {
                AMI_MyClass_opContextNotEqualIPtr cb = new AMI_MyClass_opContextNotEqualI(dflt);
                p->opContext_async(cb);
                test(cb->check());
            }

            Test::MyClassPrx p2 = Test::MyClassPrx::uncheckedCast(p->ice_context(Ice::Context()));
            {
                AMI_MyClass_opContextEqualIPtr cb = new AMI_MyClass_opContextEqualI(Ice::Context());
                p2->opContext_async(cb);
                test(cb->check());
            }

            p2 = Test::MyClassPrx::uncheckedCast(p->ice_defaultContext());
            {
                AMI_MyClass_opContextEqualIPtr cb = new AMI_MyClass_opContextEqualI(dflt);
                p2->opContext_async(cb);
                test(cb->check());
            }

            communicator->setDefaultContext(Ice::Context());
            {
                AMI_MyClass_opContextNotEqualIPtr cb = new AMI_MyClass_opContextNotEqualI(Ice::Context());
                p2->opContext_async(cb);
                test(cb->check());
            }

            communicator->setDefaultContext(dflt);
            Test::MyClassPrx c = Test::MyClassPrx::checkedCast(
                                    communicator->stringToProxy("test:default -p 12010 -t 10000"));
            {
                Ice::Context tmp;
                tmp["a"] = "b";
                AMI_MyClass_opContextEqualIPtr cb = new AMI_MyClass_opContextEqualI(tmp);
                c->opContext_async(cb);
                test(cb->check());
            }

            dflt["a"] = "c";
            Test::MyClassPrx c2 = Test::MyClassPrx::uncheckedCast(c->ice_context(dflt));
            {
                Ice::Context tmp;
                tmp["a"] = "c";
                AMI_MyClass_opContextEqualIPtr cb = new AMI_MyClass_opContextEqualI(tmp);
                c2->opContext_async(cb);
                test(cb->check());
            }

            dflt.clear();
            Test::MyClassPrx c3 = Test::MyClassPrx::uncheckedCast(c2->ice_context(dflt));
            {
                Ice::Context tmp;
                AMI_MyClass_opContextEqualIPtr cb = new AMI_MyClass_opContextEqualI(tmp);
                c3->opContext_async(cb);
                test(cb->check());
            }

            Test::MyClassPrx c4 = Test::MyClassPrx::uncheckedCast(c2->ice_defaultContext());
            {
                Ice::Context tmp;
                tmp["a"] = "b";
                AMI_MyClass_opContextEqualIPtr cb = new AMI_MyClass_opContextEqualI(tmp);
                c4->opContext_async(cb);
                test(cb->check());
            }

            dflt["a"] = "d";
            communicator->setDefaultContext(dflt);

            Test::MyClassPrx c5 = Test::MyClassPrx::uncheckedCast(c->ice_defaultContext());
            {
                Ice::Context tmp;
                tmp["a"] = "d";
                AMI_MyClass_opContextEqualIPtr cb = new AMI_MyClass_opContextEqualI(tmp);
                c5->opContext_async(cb);
                test(cb->check());
            }

            communicator->setDefaultContext(Ice::Context());
*/
        }

        {
            //
            // Test implicit context propagation
            //
            
            string impls[] = {"Shared", "PerThread"};
            for(int i = 0; i < 2; i++)
            {
                Ice::InitializationData initData;
                initData.properties = communicator->getProperties()->clone();
                initData.properties->setProperty("Ice.ImplicitContext", impls[i]);
                
                Ice::CommunicatorPtr ic = Ice::initialize(initData);

                Ice::Context ctx;
                ctx["one"] = "ONE";
                ctx["two"] = "TWO";
                ctx["three"] = "THREE";


                Test::MyClassPrx p = Test::MyClassPrx::uncheckedCast(
                                        ic->stringToProxy("test:default -p 12010 -t 10000"));
                
                
                ic->getImplicitContext()->setContext(ctx);
                test(ic->getImplicitContext()->getContext() == ctx);
                {
                    AMI_MyClass_opContextEqualIPtr cb = new AMI_MyClass_opContextEqualI(ctx);
                    p->opContext_async(cb);
                    test(cb->check());
                }

                ic->getImplicitContext()->put("zero", "ZERO");
          
                ctx = ic->getImplicitContext()->getContext();
                {
                    AMI_MyClass_opContextEqualIPtr cb = new AMI_MyClass_opContextEqualI(ctx);
                    p->opContext_async(cb);
                    test(cb->check());
                }
                
                Ice::Context prxContext;
                prxContext["one"] = "UN";
                prxContext["four"] = "QUATRE";
                
                Ice::Context combined = prxContext;
                combined.insert(ctx.begin(), ctx.end());
                test(combined["one"] == "UN");
                
                p = Test::MyClassPrx::uncheckedCast(p->ice_context(prxContext));
                
                ic->getImplicitContext()->setContext(Ice::Context());
                {
                    AMI_MyClass_opContextEqualIPtr cb = new AMI_MyClass_opContextEqualI(prxContext);
                    p->opContext_async(cb);
                    test(cb->check());
                }

                ic->getImplicitContext()->setContext(ctx);
                {
                    AMI_MyClass_opContextEqualIPtr cb = new AMI_MyClass_opContextEqualI(combined);
                    p->opContext_async(cb);
                    test(cb->check());
                }
                
                ic->destroy();
            }
        }


    }

    {
        Ice::Double d = 1278312346.0 / 13.0;
        Test::DoubleS ds(5, d);
        AMI_MyClass_opDoubleMarshalingIPtr cb = new AMI_MyClass_opDoubleMarshalingI;
        p->opDoubleMarshaling_async(cb, d, ds);
        test(cb->check());
    }

    {
        Test::MyDerivedClassPrx derived = Test::MyDerivedClassPrx::checkedCast(p);
        test(derived);
        AMI_MyDerivedClass_opDerivedIPtr cb = new AMI_MyDerivedClass_opDerivedI;
        derived->opDerived_async(cb);
        test(cb->check());
    }
}