Example #1
0
void
batchOnewaysAMI(const Test::MyClassPrx& p)
{
    const Test::ByteS bs1(10  * 1024);
    const Test::ByteS bs2(99  * 1024);
    const Test::ByteS bs3(100  * 1024);
    
    CallbackPtr cb = new Callback();
    p->begin_opByteSOneway(bs1, Test::newCallback_MyClass_opByteSOneway(new Callback_ByteSOneway1(cb),
        &Callback_ByteSOneway1::response, &Callback_ByteSOneway1::exception));
    cb->check();

    p->begin_opByteSOneway(bs2, Test::newCallback_MyClass_opByteSOneway(new Callback_ByteSOneway1(cb),
        &Callback_ByteSOneway1::response, &Callback_ByteSOneway1::exception));
    cb->check();

    Test::MyClassPrx batch = Test::MyClassPrx::uncheckedCast(p->ice_batchOneway());
    batch->end_ice_flushBatchRequests(batch->begin_ice_flushBatchRequests());

    int i;

    for(i = 0 ; i < 30 ; ++i)
    {
        p->begin_opByteSOneway(bs1, Test::newCallback_MyClass_opByteSOneway(new Callback_ByteSOneway3(), 
                                                                            &Callback_ByteSOneway3::response, 
                                                                            &Callback_ByteSOneway3::exception));
    }
    
    if(batch->ice_getConnection())
    {
        batch->ice_getConnection()->end_flushBatchRequests(batch->ice_getConnection()->begin_flushBatchRequests());

        Test::MyClassPrx batch2 = Test::MyClassPrx::uncheckedCast(p->ice_batchOneway());

        batch->begin_ice_ping();
        batch2->begin_ice_ping();
        batch->end_ice_flushBatchRequests(batch->begin_ice_flushBatchRequests());
        batch->ice_getConnection()->close(false);
        batch->begin_ice_ping();
        batch2->begin_ice_ping();

        batch->ice_getConnection();
        batch2->ice_getConnection();

        batch->begin_ice_ping();
        batch->ice_getConnection()->close(false);

        batch->begin_ice_ping(Ice::newCallback_Object_ice_ping(new Callback_ping(cb), &Callback_ping::response, &Callback_ping::exception));
        cb->check();

        batch2->begin_ice_ping(Ice::newCallback_Object_ice_ping(new Callback_ping(cb), &Callback_ping::response, &Callback_ping::exception));
        cb->check();

        batch->begin_ice_ping();
        batch2->begin_ice_ping();
    }

    Ice::Identity identity;
    identity.name = "invalid";
    Ice::ObjectPrx batch3 = batch->ice_identity(identity);
    batch3->begin_ice_ping();
    batch3->end_ice_flushBatchRequests(batch3->begin_ice_flushBatchRequests());

    // Make sure that a bogus batch request doesn't cause troubles to other ones.
    batch3->begin_ice_ping();
    batch->begin_ice_ping();
    batch->end_ice_flushBatchRequests(batch->begin_ice_flushBatchRequests());
    batch->begin_ice_ping();
}
Example #2
0
void
onewaysAMI(const Ice::CommunicatorPtr&, const Test::MyClassPrx& proxy)
{
    Test::MyClassPrx p = Test::MyClassPrx::uncheckedCast(proxy->ice_oneway());

    {
        CallbackPtr cb = new Callback;
        Ice::Callback_Object_ice_pingPtr callback =
            Ice::newCallback_Object_ice_ping(cb, &Callback::noException, &Callback::sent);
        p->begin_ice_ping(callback);
        cb->check();
    }

    {
        try
        {
            p->begin_ice_isA(Test::MyClass::ice_staticId());
            test(false);
        }
        catch(const IceUtil::IllegalArgumentException&)
        {
        }
    }
    
    {
        try
        {
            p->begin_ice_id();
            test(false);
        }
        catch(const IceUtil::IllegalArgumentException&)
        {
        }
    }
    
    {
        try
        {
            p->begin_ice_ids();
            test(false);
        }
        catch(const IceUtil::IllegalArgumentException&)
        {
        }
    }

    {
        CallbackPtr cb = new Callback;
        Test::Callback_MyClass_opVoidPtr callback =
            Test::newCallback_MyClass_opVoid(cb, &Callback::noException, &Callback::sent);
        p->begin_opVoid(callback);
        cb->check();
    }

    {
        CallbackPtr cb = new Callback;
        Test::Callback_MyClass_opIdempotentPtr callback =
            Test::newCallback_MyClass_opIdempotent(cb, &Callback::noException, &Callback::sent);
        p->begin_opIdempotent(callback);
        cb->check();
    }

    {
        CallbackPtr cb = new Callback;
        Test::Callback_MyClass_opNonmutatingPtr callback =
            Test::newCallback_MyClass_opNonmutating(cb, &Callback::noException, &Callback::sent);
        p->begin_opNonmutating(callback);
        cb->check();
    }

    {
        try
        {
            p->begin_opByte(Ice::Byte(0xff), Ice::Byte(0x0f));
            test(false);
        }
        catch(const IceUtil::IllegalArgumentException&)
        {
        }
    }
#ifdef ICE_CPP11
    {
        CallbackPtr cb = new Callback;
        p->begin_ice_ping(nullptr, 
                          [=](const Ice::Exception& ex){ cb->noException(ex); },
                          [=](bool sent){ cb->sent(sent); });
        cb->check();
    }

    {
        try
        {
            p->begin_ice_isA(Test::MyClass::ice_staticId(), [=](bool){ test(false); });
            test(false);
        }
        catch(const IceUtil::IllegalArgumentException&)
        {
        }
    }
    
    {
        try
        {
            p->begin_ice_id([=](const string&){ test(false); });
            test(false);
        }
        catch(const IceUtil::IllegalArgumentException&)
        {
        }
    }
    
    {
        try
        {
            p->begin_ice_ids([=](const Ice::StringSeq&){ test(false); });
            test(false);
        }
        catch(const IceUtil::IllegalArgumentException&)
        {
        }
    }

    {
        CallbackPtr cb = new Callback;
        p->begin_opVoid(nullptr, 
                        [=](const Ice::Exception& ex){ cb->noException(ex); },
                        [=](bool sent){ cb->sent(sent); });
        cb->check();
    }

    {
        CallbackPtr cb = new Callback;
        p->begin_opIdempotent(nullptr, 
                              [=](const Ice::Exception& ex){ cb->noException(ex); },
                              [=](bool sent){ cb->sent(sent); });
        cb->check();
    }

    {
        CallbackPtr cb = new Callback;
        p->begin_opNonmutating(nullptr, 
                               [=](const Ice::Exception& ex){ cb->noException(ex); },
                               [=](bool sent){ cb->sent(sent); });
        cb->check();
    }

    {
        try
        {
            p->begin_opByte(Ice::Byte(0xff), Ice::Byte(0x0f), [=](const Ice::Byte&, const Ice::Byte&){ test(false); });
            test(false);
        }
        catch(const IceUtil::IllegalArgumentException&)
        {
        }
    }
#endif
}