C++ (Cpp) MyClassPrx::ice_pingの例

コード例 #1

ファイル: Oneways.cpp プロジェクト: joshmoore/zeroc-ice

void
oneways(const Ice::CommunicatorPtr& communicator, const Test::MyClassPrx& proxy)
{
    Test::MyClassPrx p = Test::MyClassPrx::uncheckedCast(proxy->ice_oneway());
    
    {
        p->ice_ping();
    }

    {
        try
        {
            p->ice_isA("dummy");
            test(false);
        }
        catch(const Ice::TwowayOnlyException&)
        {
        }
    }

    {
        try
        {
            p->ice_id();
            test(false);
        }
        catch(const Ice::TwowayOnlyException&)
        {
        }
    }

    {
        try
        {
            p->ice_ids();
            test(false);
        }
        catch(const Ice::TwowayOnlyException&)
        {
        }
    }    

    {
        p->opVoid();
    }

    {
        p->opIdempotent();
    }

    {
        p->opNonmutating();
    }

    {
        Ice::Byte b;

        try
        {
            p->opByte(Ice::Byte(0xff), Ice::Byte(0x0f), b);
            test(false);
        }
        catch(const Ice::TwowayOnlyException&)
        {
        }
    }

}

コード例 #2

ファイル: BatchOneways.cpp プロジェクト: bholl/zeroc-ice

void
batchOneways(const Test::MyClassPrx& p)
{
    const Test::ByteS bs1(10  * 1024);
    const Test::ByteS bs2(99  * 1024);
    const Test::ByteS bs3(100  * 1024);
    try
    {
        p->opByteSOneway(bs1);
    }
    catch(const Ice::MemoryLimitException&)
    {
        test(false);
    }

    try
    {
        p->opByteSOneway(bs2);
    }
    catch(const Ice::MemoryLimitException&)
    {
        test(false);
    }
    
    try
    {
        p->opByteSOneway(bs3);
        test(false);
    }
    catch(const Ice::MemoryLimitException&)
    {
    }
    
    Test::MyClassPrx batch = Test::MyClassPrx::uncheckedCast(p->ice_batchOneway());
    
    int i;

    for(i = 0 ; i < 30 ; ++i)
    {
        try
        {
            batch->opByteSOneway(bs1);
        }
        catch(const Ice::MemoryLimitException&)
        {
            test(false);
        }
    }
    
    batch->ice_getConnection()->flushBatchRequests();

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

    batch->ice_ping();
    batch2->ice_ping();
    batch->ice_flushBatchRequests();
    batch->ice_getConnection()->close(false);
    batch->ice_ping();
    batch2->ice_ping();

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

    batch->ice_ping();
    batch->ice_getConnection()->close(false);
    try
    {
        batch->ice_ping();
        test(false);
    }
    catch(const Ice::CloseConnectionException&)
    {
    }
    try
    {
        batch2->ice_ping();
        test(false);
    }
    catch(const Ice::CloseConnectionException&)
    {
    }
    batch->ice_ping();
    batch2->ice_ping();
}