alltests.cpp

ICE-3.2 一个开源的中间件

// **********************************************************************
//
// Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

#include <Ice/Ice.h>
#include <TestCommon.h>
#include <ClientPrivate.h>
#include <sstream>

using namespace std;
using namespace Test;

class CallbackBase : public IceUtil::Monitor<IceUtil::Mutex>
{
public:

    CallbackBase() :
        _called(false)
    {
    }

    virtual ~CallbackBase()
    {
    }

    bool check()
    {
        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
        while(!_called)
        {
            if(!timedWait(IceUtil::Time::seconds(5)))
            {
                return false;
            }
        }
        _called = false;
        return true;
    }

protected:

    void called()
    {
        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
        assert(!_called);
        _called = true;
        notify();
    }

private:

    bool _called;
};

class AMI_Test_SBaseAsObjectI : public AMI_TestIntf_SBaseAsObject, public CallbackBase
{
    virtual void
    ice_response(const ::Ice::ObjectPtr& o)
    {
        test(o);
        test(o->ice_id() == "::Test::SBase");
        SBasePtr sb = SBasePtr::dynamicCast(o);
        test(sb);
        test(sb->sb == "SBase.sb");
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_SBaseAsObjectI> AMI_Test_SBaseAsObjectIPtr;

class AMI_Test_SBaseAsSBaseI : public AMI_TestIntf_SBaseAsSBase, public CallbackBase
{
    virtual void
    ice_response(const SBasePtr& sb)
    {
        test(sb->sb == "SBase.sb");
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_SBaseAsSBaseI> AMI_Test_SBaseAsSBaseIPtr;

class AMI_Test_SBSKnownDerivedAsSBaseI : public AMI_TestIntf_SBSKnownDerivedAsSBase, public CallbackBase
{
    virtual void
    ice_response(const SBasePtr& sb)
    {
        SBSKnownDerivedPtr sbskd = SBSKnownDerivedPtr::dynamicCast(sb);
        test(sbskd);
        test(sbskd->sbskd == "SBSKnownDerived.sbskd");
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_SBSKnownDerivedAsSBaseI> AMI_Test_SBSKnownDerivedAsSBaseIPtr;

class AMI_Test_SBSKnownDerivedAsSBSKnownDerivedI
    : public AMI_TestIntf_SBSKnownDerivedAsSBSKnownDerived, public CallbackBase
{
    virtual void
    ice_response(const SBSKnownDerivedPtr& sbskd)
    {
        test(sbskd->sbskd == "SBSKnownDerived.sbskd");
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_SBSKnownDerivedAsSBSKnownDerivedI> AMI_Test_SBSKnownDerivedAsSBSKnownDerivedIPtr;

class AMI_Test_SBSUnknownDerivedAsSBaseI : public AMI_TestIntf_SBSUnknownDerivedAsSBase, public CallbackBase
{
    virtual void
    ice_response(const SBasePtr& sb)
    {
        test(sb->sb == "SBSUnknownDerived.sb");
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_SBSUnknownDerivedAsSBaseI> AMI_Test_SBSUnknownDerivedAsSBaseIPtr;

class AMI_Test_SUnknownAsObjectI : public AMI_TestIntf_SUnknownAsObject, public CallbackBase
{
    virtual void
    ice_response(const Ice::ObjectPtr& o)
    {
        test(false);
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(exc.ice_name() == "Ice::NoObjectFactoryException");
        called();
    }
};

typedef IceUtil::Handle<AMI_Test_SUnknownAsObjectI> AMI_Test_SUnknownAsObjectIPtr;

class AMI_Test_oneElementCycleI : public AMI_TestIntf_oneElementCycle, public CallbackBase
{
    virtual void
    ice_response(const BPtr& b)
    {
        test(b);
        test(b->ice_id() == "::Test::B");
        test(b->sb == "B1.sb");
        test(b->pb == b);
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_oneElementCycleI> AMI_Test_oneElementCycleIPtr;

class AMI_Test_twoElementCycleI : public AMI_TestIntf_twoElementCycle, public CallbackBase
{
    virtual void
    ice_response(const BPtr& b1)
    {
        test(b1);
        test(b1->ice_id() == "::Test::B");
        test(b1->sb == "B1.sb");

        BPtr b2 = b1->pb;
        test(b2);
        test(b2->ice_id() == "::Test::B");
        test(b2->sb == "B2.sb");
        test(b2->pb == b1);
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_twoElementCycleI> AMI_Test_twoElementCycleIPtr;

class AMI_Test_D1AsBI : public AMI_TestIntf_D1AsB, public CallbackBase
{
    virtual void
    ice_response(const BPtr& b1)
    {
        test(b1);
        test(b1->ice_id() == "::Test::D1");
        test(b1->sb == "D1.sb");
        test(b1->pb);
        test(b1->pb != b1);
        D1Ptr d1 = D1Ptr::dynamicCast(b1);
        test(d1);
        test(d1->sd1 == "D1.sd1");
        test(d1->pd1);
        test(d1->pd1 != b1);
        test(b1->pb == d1->pd1);

        BPtr b2 = b1->pb;
        test(b2);
        test(b2->pb == b1);
        test(b2->sb == "D2.sb");
        test(b2->ice_id() == "::Test::B");
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_D1AsBI> AMI_Test_D1AsBIPtr;

class AMI_Test_D1AsD1I : public AMI_TestIntf_D1AsD1, public CallbackBase
{
    virtual void
    ice_response(const D1Ptr& d1)
    {
        test(d1);
        test(d1->ice_id() == "::Test::D1");
        test(d1->sb == "D1.sb");
        test(d1->pb);
        test(d1->pb != d1);

        BPtr b2 = d1->pb;
        test(b2);
        test(b2->ice_id() == "::Test::B");
        test(b2->sb == "D2.sb");
        test(b2->pb == d1);
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_D1AsD1I> AMI_Test_D1AsD1IPtr;

class AMI_Test_D2AsBI : public AMI_TestIntf_D2AsB, public CallbackBase
{
    virtual void
    ice_response(const BPtr& b2)
    {
        test(b2);
        test(b2->ice_id() == "::Test::B");
        test(b2->sb == "D2.sb");
        test(b2->pb);
        test(b2->pb != b2);

        BPtr b1 = b2->pb;
        test(b1);
        test(b1->ice_id() == "::Test::D1");
        test(b1->sb == "D1.sb");
        test(b1->pb == b2);
        D1Ptr d1 = D1Ptr::dynamicCast(b1);
        test(d1);
        test(d1->sd1 == "D1.sd1");
        test(d1->pd1 == b2);
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_D2AsBI> AMI_Test_D2AsBIPtr;

class AMI_Test_paramTest1I : public AMI_TestIntf_paramTest1, public CallbackBase
{
    virtual void
    ice_response(const BPtr& b1, const BPtr& b2)
    {
        test(b1);
        test(b1->ice_id() == "::Test::D1");
        test(b1->sb == "D1.sb");
        test(b1->pb == b2);
        D1Ptr d1 = D1Ptr::dynamicCast(b1);
        test(d1);
        test(d1->sd1 == "D1.sd1");
        test(d1->pd1 == b2);

        test(b2);
        test(b2->ice_id() == "::Test::B");      // No factory, must be sliced
        test(b2->sb == "D2.sb");
        test(b2->pb == b1);
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_paramTest1I> AMI_Test_paramTest1IPtr;

class AMI_Test_returnTest1I : public AMI_TestIntf_returnTest1, public CallbackBase
{
    virtual void
    ice_response(const BPtr& r, const BPtr& p1, const BPtr& p2)
    {
        test(r == p1);
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_returnTest1I> AMI_Test_returnTest1IPtr;

class AMI_Test_returnTest2I : public AMI_TestIntf_returnTest2, public CallbackBase
{
    virtual void
    ice_response(const BPtr& r, const BPtr& p1, const BPtr& p2)
    {
        test(r == p1);
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_returnTest2I> AMI_Test_returnTest2IPtr;

class AMI_Test_returnTest3I : public AMI_TestIntf_returnTest3, public CallbackBase
{
public:
    virtual void
    ice_response(const BPtr& b)
    {
        r = b;
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }

    BPtr r;
};

typedef IceUtil::Handle<AMI_Test_returnTest3I> AMI_Test_returnTest3IPtr;

class AMI_Test_paramTest3I : public AMI_TestIntf_paramTest3, public CallbackBase
{
    virtual void
    ice_response(const BPtr& ret, const BPtr& p1, const BPtr& p2)
    {
        test(p1);
        test(p1->sb == "D2.sb (p1 1)");
        test(p1->pb == 0);
        test(p1->ice_id() == "::Test::B");

        test(p2);
        test(p2->sb == "D2.sb (p2 1)");
        test(p2->pb == 0);
        test(p2->ice_id() == "::Test::B");

        test(ret);
        test(ret->sb == "D1.sb (p2 2)");
        test(ret->pb == 0);
        test(ret->ice_id() == "::Test::D1");
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_paramTest3I> AMI_Test_paramTest3IPtr;

class AMI_Test_paramTest4I : public AMI_TestIntf_paramTest4, public CallbackBase
{
    virtual void
    ice_response(const BPtr& ret, const BPtr& b)
    {
        test(b);
        test(b->sb == "D4.sb (1)");
        test(b->pb == 0);
        test(b->ice_id() == "::Test::B");

        test(ret);
        test(ret->sb == "B.sb (2)");
        test(ret->pb == 0);
        test(ret->ice_id() == "::Test::B");
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }
};

typedef IceUtil::Handle<AMI_Test_paramTest4I> AMI_Test_paramTest4IPtr;

class AMI_Test_sequenceTestI : public AMI_TestIntf_sequenceTest, public CallbackBase
{
    virtual void
    ice_response(const SS& ss)
    {
        r = ss;
        called();
    }

    virtual void
    ice_exception(const Ice::Exception& exc)
    {
        test(false);
    }

public:

    SS r;
};