Exemple #1
0
Test::MyClassPrxPtr
allTests(const Ice::CommunicatorPtr& communicator)
{
    string ref = "test:" + getTestEndpoint(communicator, 0);
    Ice::ObjectPrxPtr base = communicator->stringToProxy(ref);
    test(base);

    Test::MyClassPrxPtr cl = ICE_CHECKED_CAST(Test::MyClassPrx, base);
    test(cl);

    Test::MyClassPrxPtr oneway = cl->ice_oneway();
    Test::MyClassPrxPtr batchOneway = cl->ice_batchOneway();

    cout << "testing ice_invoke... " << flush;

    {
        Ice::ByteSeq inEncaps, outEncaps;
        if(!oneway->ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps))
        {
            test(false);
        }

        test(batchOneway->ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
        test(batchOneway->ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
        test(batchOneway->ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
        test(batchOneway->ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
        batchOneway->ice_flushBatchRequests();

        Ice::OutputStream out(communicator);
        out.startEncapsulation();
        out.write(testString);
        out.endEncapsulation();
        out.finished(inEncaps);

        // ice_invoke
        if(cl->ice_invoke("opString", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps))
        {
            Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
            in.startEncapsulation();
            string s;
            in.read(s);
            test(s == testString);
            in.read(s);
            test(s == testString);
            in.endEncapsulation();
        }
        else
        {
            test(false);
        }

        // ice_invoke with array mapping
        pair<const ::Ice::Byte*, const ::Ice::Byte*> inPair(&inEncaps[0], &inEncaps[0] + inEncaps.size());
        if(cl->ice_invoke("opString", ICE_ENUM(OperationMode, Normal), inPair, outEncaps))
        {
            Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
            in.startEncapsulation();
            string s;
            in.read(s);
            test(s == testString);
            in.read(s);
            test(s == testString);
            in.endEncapsulation();
        }
        else
        {
            test(false);
        }
    }

    for(int i = 0; i < 2; ++i)
    {
        Ice::ByteSeq inEncaps, outEncaps;
        Ice::Context ctx;
        if(i == 1)
        {
            ctx["raise"] = "";
        }
        if(cl->ice_invoke("opException", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps, ctx))
        {
            test(false);
        }
        else
        {
            Ice::InputStream in(communicator, cl->ice_getEncodingVersion(), outEncaps);
            in.startEncapsulation();
            try
            {
                in.throwException();
            }
            catch(const Test::MyException&)
            {
            }
            catch(...)
            {
                test(false);
            }
            in.endEncapsulation();
        }
    }

    cout << "ok" << endl;

    cout << "testing asynchronous ice_invoke... " << flush;
#ifdef ICE_CPP11_MAPPING

    {
        Ice::ByteSeq inEncaps;
        batchOneway->ice_invokeAsync("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps,
            [](bool, const vector<Ice::Byte>)
            {
                test(false);
            },
            [](exception_ptr)
            {
                test(false);
            },
            [](bool)
            {
                test(false);
            });
        batchOneway->ice_flushBatchRequests();
    }
    //
    // repeat with the future API.
    //
    {
        Ice::ByteSeq inEncaps;
        test(batchOneway->ice_invokeAsync("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps).get().returnValue);
        test(batchOneway->ice_invokeAsync("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps).get().returnValue);
        test(batchOneway->ice_invokeAsync("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps).get().returnValue);
        test(batchOneway->ice_invokeAsync("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps).get().returnValue);
        batchOneway->ice_flushBatchRequests();
    }

    {
        promise<bool> completed;
        Ice::ByteSeq inEncaps, outEncaps;
        oneway->ice_invokeAsync(
            "opOneway",
            OperationMode::Normal,
            inEncaps,
            nullptr,
            [&](exception_ptr ex)
            {
                completed.set_exception(ex);
            },
            [&](bool)
            {
                completed.set_value(true);
            });

        test(completed.get_future().get());
    }

    //
    // repeat with the future API.
    //

    {
        Ice::ByteSeq inEncaps, outEncaps;
        auto completed = oneway->ice_invokeAsync("opOneway", OperationMode::Normal, inEncaps);
        test(completed.get().returnValue);
    }

    {
        promise<bool> completed;
        Ice::ByteSeq inEncaps, outEncaps;
        Ice::OutputStream out(communicator);
        out.startEncapsulation();
        out.write(testString);
        out.endEncapsulation();
        out.finished(inEncaps);

        cl->ice_invokeAsync("opString", OperationMode::Normal, inEncaps,
            [&](bool ok, vector<Ice::Byte> outParams)
            {
                outEncaps = move(outParams);
                completed.set_value(ok);
            },
            [&](exception_ptr ex)
            {
                completed.set_exception(ex);
            });
        test(completed.get_future().get());

        Ice::InputStream in(communicator, outEncaps);
        in.startEncapsulation();
        string s;
        in.read(s);
        test(s == testString);
        in.read(s);
        test(s == testString);
        in.endEncapsulation();
    }
    //
    // repeat with the future API.
    //
    {
        Ice::ByteSeq inEncaps, outEncaps;
        Ice::OutputStream out(communicator);
        out.startEncapsulation();
        out.write(testString);
        out.endEncapsulation();
        out.finished(inEncaps);

        auto result = cl->ice_invokeAsync("opString", OperationMode::Normal, inEncaps).get();
        test(result.returnValue);

        Ice::InputStream in(communicator, result.outParams);
        in.startEncapsulation();
        string s;
        in.read(s);
        test(s == testString);
        in.read(s);
        test(s == testString);
        in.endEncapsulation();
    }

    {
        promise<bool> completed;
        promise<void> sent;
        Ice::ByteSeq inEncaps, outEncaps;
        Ice::OutputStream out(communicator);
        out.startEncapsulation();
        out.write(testString);
        out.endEncapsulation();
        out.finished(inEncaps);

        auto inPair = make_pair(inEncaps.data(), inEncaps.data() + inEncaps.size());

        cl->ice_invokeAsync("opString", OperationMode::Normal, inPair,
            [&](bool ok, pair<const Ice::Byte*, const Ice::Byte*> outParams)
            {
                vector<Ice::Byte>(outParams.first, outParams.second).swap(outEncaps);
                completed.set_value(ok);
            },
            [&](exception_ptr ex)
            {
                completed.set_exception(ex);
            },
            [&](bool)
            {
                sent.set_value();
            });
        sent.get_future().get(); // Ensure sent callback was called
        test(completed.get_future().get());

        Ice::InputStream in(communicator, outEncaps);
        in.startEncapsulation();
        string s;
        in.read(s);
        test(s == testString);
        in.read(s);
        test(s == testString);
        in.endEncapsulation();
    }
    //
    // repeat with the future API.
    //

    {
        Ice::ByteSeq inEncaps, outEncaps;
        Ice::OutputStream out(communicator);
        out.startEncapsulation();
        out.write(testString);
        out.endEncapsulation();
        out.finished(inEncaps);

        auto inPair = make_pair(inEncaps.data(), inEncaps.data() + inEncaps.size());

        auto result = cl->ice_invokeAsync("opString", OperationMode::Normal, inPair).get();
        test(result.returnValue);

        Ice::InputStream in(communicator, result.outParams);
        in.startEncapsulation();
        string s;
        in.read(s);
        test(s == testString);
        in.read(s);
        test(s == testString);
        in.endEncapsulation();
    }

    {
        promise<bool> completed;
        promise<void> sent;
        Ice::ByteSeq inEncaps, outEncaps;

        cl->ice_invokeAsync("opException", OperationMode::Normal, inEncaps,
            [&](bool ok, vector<Ice::Byte> outParams)
            {
                outEncaps = move(outParams);
                completed.set_value(ok);
            },
            [&](exception_ptr ex)
            {
                completed.set_exception(ex);
            },
            [&](bool)
            {
                sent.set_value();
            });
        sent.get_future().get(); // Ensure sent callback was called
        test(!completed.get_future().get());

        Ice::InputStream in(communicator, outEncaps);
        in.startEncapsulation();
        try
        {
            in.throwException();
            test(false);
        }
        catch(const Test::MyException&)
        {
        }
        catch(...)
        {
            test(false);
        }
    }
    //
    // repeat with the future API.
    //
    {
        Ice::ByteSeq inEncaps;
        auto result = cl->ice_invokeAsync("opException", OperationMode::Normal, inEncaps).get();
        test(!result.returnValue);

        Ice::InputStream in(communicator, result.outParams);
        in.startEncapsulation();
        try
        {
            in.throwException();
            test(false);
        }
        catch(const Test::MyException&)
        {
        }
        catch(...)
        {
            test(false);
        }
    }

#else
    void (::Callback::*nullEx)(const Ice::Exception&) = 0;
    void (::Callback::*nullExWC)(const Ice::Exception&, const CookiePtr&) = 0;

    {
        Ice::ByteSeq inEncaps, outEncaps;
        test(batchOneway->end_ice_invoke(outEncaps, batchOneway->begin_ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps)));
        test(batchOneway->end_ice_invoke(outEncaps, batchOneway->begin_ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps)));
        test(batchOneway->end_ice_invoke(outEncaps, batchOneway->begin_ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps)));
        test(batchOneway->end_ice_invoke(outEncaps, batchOneway->begin_ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps)));
        batchOneway->ice_flushBatchRequests();
    }

    {
        CookiePtr cookie = new Cookie();

        Ice::ByteSeq inEncaps, outEncaps;
        Ice::AsyncResultPtr result = oneway->begin_ice_invoke("opOneway", Ice::Normal, inEncaps);
        if(!oneway->end_ice_invoke(outEncaps, result))
        {
            test(false);
        }

        Ice::OutputStream out(communicator);
        out.startEncapsulation();
        out.write(testString);
        out.endEncapsulation();
        out.finished(inEncaps);

        // begin_ice_invoke with no callback
        result = cl->begin_ice_invoke("opString", Ice::Normal, inEncaps);
        if(cl->end_ice_invoke(outEncaps, result))
        {
            Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
            in.startEncapsulation();
            string s;
            in.read(s);
            test(s == testString);
            in.read(s);
            test(s == testString);
            in.endEncapsulation();
        }
        else
        {
            test(false);
        }

        // begin_ice_invoke with no callback and array mapping
        pair<const ::Ice::Byte*, const ::Ice::Byte*> inPair(&inEncaps[0], &inEncaps[0] + inEncaps.size());
        result = cl->begin_ice_invoke("opString", Ice::Normal, inPair);
        if(cl->end_ice_invoke(outEncaps, result))
        {
            Ice::InputStream in(communicator, out.getEncoding(), outEncaps);
            in.startEncapsulation();
            string s;
            in.read(s);
            test(s == testString);
            in.read(s);
            test(s == testString);
            in.endEncapsulation();
        }
        else
        {
            test(false);
        }

        // begin_ice_invoke with Callback
        ::CallbackPtr cb = new ::Callback(communicator, false);
        cl->begin_ice_invoke("opString", Ice::Normal, inEncaps, Ice::newCallback(cb, &Callback::opString));
        cb->check();

        // begin_ice_invoke with Callback and Cookie
        cb = new ::Callback(communicator, true);
        cl->begin_ice_invoke("opString", Ice::Normal, inEncaps, Ice::newCallback(cb, &Callback::opString), cookie);
        cb->check();

        // begin_ice_invoke with Callback_Object_ice_invoke
        cb = new ::Callback(communicator, false);
        Ice::Callback_Object_ice_invokePtr d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opStringNC, nullEx);
        cl->begin_ice_invoke("opString", Ice::Normal, inEncaps, d);
        cb->check();

        // begin_ice_invoke with Callback_Object_ice_invoke with Cookie
        cb = new ::Callback(communicator, false);
        d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opStringWC, nullExWC);
        cl->begin_ice_invoke("opString", Ice::Normal, inEncaps, d, cookie);
        cb->check();

        // begin_ice_invoke with Callback_Object_ice_invoke and array mapping
        cb = new ::Callback(communicator, false);
        d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opStringNC, nullEx);
        cl->begin_ice_invoke("opString", Ice::Normal, inPair, d);
        cb->check();

        // begin_ice_invoke with Callback_Object_ice_invoke and array mapping with Cookie
        cb = new ::Callback(communicator, false);
        d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opStringWC, nullExWC);
        cl->begin_ice_invoke("opString", Ice::Normal, inPair, d, cookie);
        cb->check();
    }

    {
        CookiePtr cookie = new Cookie();
        Ice::ByteSeq inEncaps, outEncaps;

        // begin_ice_invoke with no callback
        Ice::AsyncResultPtr result = cl->begin_ice_invoke("opException", Ice::Normal, inEncaps);
        if(cl->end_ice_invoke(outEncaps, result))
        {
            test(false);
        }
        else
        {
            Ice::InputStream in(communicator, cl->ice_getEncodingVersion(), outEncaps);
            in.startEncapsulation();
            try
            {
                in.throwException();
            }
            catch(const Test::MyException&)
            {
            }
            catch(...)
            {
                test(false);
            }
            in.endEncapsulation();
        }

        // begin_ice_invoke with Callback
        ::CallbackPtr cb = new ::Callback(communicator, false);
        cl->begin_ice_invoke("opException", Ice::Normal, inEncaps, Ice::newCallback(cb, &Callback::opException));
        cb->check();

        // begin_ice_invoke with Callback and Cookie
        cb = new ::Callback(communicator, true);
        cl->begin_ice_invoke("opException", Ice::Normal, inEncaps, Ice::newCallback(cb, &Callback::opException),
                             cookie);
        cb->check();

        // begin_ice_invoke with Callback_Object_ice_invoke
        cb = new ::Callback(communicator, false);
        Ice::Callback_Object_ice_invokePtr d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opExceptionNC, nullEx);
        cl->begin_ice_invoke("opException", Ice::Normal, inEncaps, d);
        cb->check();

        // begin_ice_invoke with Callback_Object_ice_invoke with Cookie
        cb = new ::Callback(communicator, false);
        d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opExceptionWC, nullExWC);
        cl->begin_ice_invoke("opException", Ice::Normal, inEncaps, d, cookie);
        cb->check();
    }
#endif
    cout << "ok" << endl;
    return cl;
}
Exemple #2
0
void
batchOneways(const Test::MyClassPrxPtr& p)
{
    const Test::ByteS bs1(10  * 1024);

    Test::MyClassPrxPtr batch = ICE_UNCHECKED_CAST(Test::MyClassPrx, p->ice_batchOneway());

    batch->ice_flushBatchRequests(); // Empty flush
    if(batch->ice_getConnection())
    {
        batch->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy));
    }
    batch->ice_getCommunicator()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy));

    int i;
    p->opByteSOnewayCallCount(); // Reset the call count
    for(i = 0 ; i < 30 ; ++i)
    {
        try
        {
            batch->opByteSOneway(bs1);
        }
        catch(const Ice::LocalException& ex)
        {
            cerr << ex << endl;
            test(false);
        }
    }

    int count = 0;
    while(count < 27) // 3 * 9 requests auto-flushed.
    {
        count += p->opByteSOnewayCallCount();
        IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
    }

    if(batch->ice_getConnection() &&
       p->ice_getCommunicator()->getProperties()->getProperty("Ice.Default.Protocol") != "bt")
    {
        Test::MyClassPrxPtr batch1 = ICE_UNCHECKED_CAST(Test::MyClassPrx, p->ice_batchOneway());
        Test::MyClassPrxPtr batch2 = ICE_UNCHECKED_CAST(Test::MyClassPrx, p->ice_batchOneway());

        batch1->ice_ping();
        batch2->ice_ping();
        batch1->ice_flushBatchRequests();
        batch1->ice_getConnection()->close(Ice::ICE_SCOPED_ENUM(ConnectionClose, GracefullyWithWait));
        batch1->ice_ping();
        batch2->ice_ping();

        batch1->ice_getConnection();
        batch2->ice_getConnection();

        batch1->ice_ping();
        batch1->ice_getConnection()->close(Ice::ICE_SCOPED_ENUM(ConnectionClose, GracefullyWithWait));
        batch1->ice_ping();
        batch2->ice_ping();
    }

    Ice::Identity identity;
    identity.name = "invalid";
    Ice::ObjectPrxPtr batch3 = batch->ice_identity(identity);
    batch3->ice_ping();
    batch3->ice_flushBatchRequests();

    // Make sure that a bogus batch request doesn't cause troubles to other ones.
    batch3->ice_ping();
    batch->ice_ping();
    batch->ice_flushBatchRequests();
    batch->ice_ping();

    if(batch->ice_getConnection() &&
       p->ice_getCommunicator()->getProperties()->getProperty("Ice.Default.Protocol") != "bt")
    {
        Ice::InitializationData initData;
        initData.properties = p->ice_getCommunicator()->getProperties()->clone();
        BatchRequestInterceptorIPtr interceptor = ICE_MAKE_SHARED(BatchRequestInterceptorI);

#if defined(ICE_CPP11_MAPPING)
        initData.batchRequestInterceptor = [=](const Ice::BatchRequest& request, int count, int size)
        {
            interceptor->enqueue(request, count, size);
        };
#else
        initData.batchRequestInterceptor = interceptor;
#endif
        Ice::CommunicatorPtr ic = Ice::initialize(initData);

        Test::MyClassPrxPtr batch =
            ICE_UNCHECKED_CAST(Test::MyClassPrx, ic->stringToProxy(p->ice_toString()))->ice_batchOneway();

        test(interceptor->count() == 0);
        batch->ice_ping();
        batch->ice_ping();
        batch->ice_ping();
        test(interceptor->count() == 0);

        interceptor->enqueue(true);
        batch->ice_ping();
        batch->ice_ping();
        batch->ice_ping();
        test(interceptor->count() == 3);

        batch->ice_flushBatchRequests();
        batch->ice_ping();
        test(interceptor->count() == 1);

        batch->opByteSOneway(bs1);
        test(interceptor->count() == 2);
        batch->opByteSOneway(bs1);
        test(interceptor->count() == 3);

        batch->opByteSOneway(bs1); // This should trigger the flush
        batch->ice_ping();
        test(interceptor->count() == 2);

        ic->destroy();
    }

    bool supportsCompress = true;
    try
    {
        supportsCompress = p->supportsCompress();
    }
    catch(const Ice::OperationNotExistException&)
    {
    }

    if(supportsCompress && batch->ice_getConnection() &&
       p->ice_getCommunicator()->getProperties()->getProperty("Ice.Override.Compress") == "")
    {
        Ice::ObjectPrxPtr prx = batch->ice_getConnection()->createProxy(batch->ice_getIdentity())->ice_batchOneway();

        Test::MyClassPrxPtr batch1 = ICE_UNCHECKED_CAST(Test::MyClassPrx, prx->ice_compress(false));
        Test::MyClassPrxPtr batch2 = ICE_UNCHECKED_CAST(Test::MyClassPrx, prx->ice_compress(true));
        Test::MyClassPrxPtr batch3 = ICE_UNCHECKED_CAST(Test::MyClassPrx, prx->ice_identity(identity));

        batch1->opByteSOneway(bs1);
        batch1->opByteSOneway(bs1);
        batch1->opByteSOneway(bs1);
        batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, Yes));

        batch2->opByteSOneway(bs1);
        batch2->opByteSOneway(bs1);
        batch2->opByteSOneway(bs1);
        batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, No));

        batch1->opByteSOneway(bs1);
        batch1->opByteSOneway(bs1);
        batch1->opByteSOneway(bs1);
        batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy));

        batch1->opByteSOneway(bs1);
        batch2->opByteSOneway(bs1);
        batch1->opByteSOneway(bs1);
        batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy));

        batch1->opByteSOneway(bs1);
        batch3->opByteSOneway(bs1);
        batch1->opByteSOneway(bs1);
        batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy));
    }
}
void
batchOnewaysAMI(const Test::MyClassPrxPtr& p)
{
    const Test::ByteS bs1(10 * 1024);
    Test::MyClassPrxPtr batch = ICE_UNCHECKED_CAST(Test::MyClassPrx, p->ice_batchOneway());
#ifdef ICE_CPP11_MAPPING

    promise<void> prom;
    batch->ice_flushBatchRequestsAsync(nullptr,
        [&](bool sentSynchronously)
        {
            test(sentSynchronously);
            prom.set_value();
        }); // Empty flush
    prom.get_future().get();

    for(int i = 0; i < 30; ++i)
    {
        batch->opByteSOnewayAsync(bs1, nullptr, [](exception_ptr){ test(false); });
    }

    int count = 0;
    while(count < 27) // 3 * 9 requests auto-flushed.
    {
        count += p->opByteSOnewayCallCount();
        IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
    }

    if(batch->ice_getConnection() &&
       p->ice_getCommunicator()->getProperties()->getProperty("Ice.Default.Protocol") != "bt")
    {
        shared_ptr<Test::MyClassPrx> batch1 = Ice::uncheckedCast<Test::MyClassPrx>(p->ice_batchOneway());
        shared_ptr<Test::MyClassPrx> batch2 = Ice::uncheckedCast<Test::MyClassPrx>(p->ice_batchOneway());

        batch1->ice_pingAsync().get();
        batch2->ice_pingAsync().get();
        batch1->ice_flushBatchRequestsAsync().get();
        batch1->ice_getConnection()->close(false);
        batch1->ice_pingAsync().get();
        batch2->ice_pingAsync().get();

        batch1->ice_getConnection();
        batch2->ice_getConnection();

        batch1->ice_pingAsync().get();
        batch1->ice_getConnection()->close(false);

        batch1->ice_pingAsync().get();
        batch2->ice_pingAsync().get();
    }

    Ice::Identity identity;
    identity.name = "invalid";
    auto batch3 = batch->ice_identity(identity);
    batch3->ice_pingAsync();
    batch3->ice_flushBatchRequestsAsync().get();

    // Make sure that a bogus batch request doesn't cause troubles to other ones.
    batch3->ice_pingAsync();
    batch->ice_pingAsync();
    batch->ice_flushBatchRequestsAsync().get();
    batch->ice_pingAsync();
#else
    batch->end_ice_flushBatchRequests(batch->begin_ice_flushBatchRequests()); // Empty flush

    test(batch->begin_ice_flushBatchRequests()->isSent()); // Empty flush
    test(batch->begin_ice_flushBatchRequests()->isCompleted()); // Empty flush
    test(batch->begin_ice_flushBatchRequests()->sentSynchronously()); // Empty flush

    for(int i = 0; i < 30; ++i)
    {
        batch->begin_opByteSOneway(bs1, Test::newCallback_MyClass_opByteSOneway(new Callback_ByteSOneway(),
                                                                                &Callback_ByteSOneway::response,
                                                                                &Callback_ByteSOneway::exception));
    }

    int count = 0;
    while(count < 27) // 3 * 9 requests auto-flushed.
    {
        count += p->opByteSOnewayCallCount();
        IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
    }

    if(batch->ice_getConnection() &&
       p->ice_getCommunicator()->getProperties()->getProperty("Ice.Default.Protocol") != "bt")
    {
        Test::MyClassPrx batch1 = Test::MyClassPrx::uncheckedCast(p->ice_batchOneway());
        Test::MyClassPrx batch2 = Test::MyClassPrx::uncheckedCast(p->ice_batchOneway());

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

        batch1->ice_getConnection();
        batch2->ice_getConnection();

        batch1->end_ice_ping(batch1->begin_ice_ping());
        batch1->ice_getConnection()->close(false);

        batch1->end_ice_ping(batch1->begin_ice_ping());
        batch2->end_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();
#endif
}