// **********************************************************************
//
// Copyright (c) 2003-2006 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 <IceUtil/Thread.h>
#include <IceUtil/Random.h>
#include <Ice/Ice.h>
#include <IceGrid/Registry.h>
#include <IceGrid/Admin.h>
#include <IceGrid/Query.h>
#include <Glacier2/Router.h>
#include <TestCommon.h>
#include <Test.h>

using namespace std;
using namespace Test;
using namespace IceGrid;

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

    Callback() : _response(false), _exception(false)
    {
    }

    void
    response(const Ice::ObjectPrx& obj)
    {
	Lock sync(*this);
	_response = true;
	_obj = obj;
	notify();
    }

    void
    exception()
    {
	Lock sync(*this);
	_exception = true;
	notify();
    }

    void
    waitResponse(char* file, int line)
    {
	Lock sync(*this);
	while(!_response && !_exception)
	{
	    if(!timedWait(IceUtil::Time::seconds(3)))
	    {
		cerr << "timeout: " << file << ":" << line << endl;
		test(false); // Timeout
	    }
	}
    }

    bool
    hasResponse(Ice::ObjectPrx& obj)
    {
	Lock sync(*this);
	obj = _obj;
	return _response;
    }

    bool
    hasException()
    {
	Lock sync(*this);
	return _exception;
    }

private:

    bool _response;
    bool _exception;
    Ice::ObjectPrx _obj;
};

class AllocateObjectByIdCallback : public AMI_Session_allocateObjectById, public Callback
{
public:

    virtual void ice_response(const Ice::ObjectPrx& obj) { response(obj); }
    virtual void ice_exception(const Ice::Exception&) { exception(); }
};
typedef IceUtil::Handle<AllocateObjectByIdCallback> AllocateObjectByIdCallbackPtr;

class AllocateObjectByTypeCallback : public AMI_Session_allocateObjectByType, public Callback
{
public:

    virtual void ice_response(const Ice::ObjectPrx& obj) { response(obj); }
    virtual void ice_exception(const Ice::Exception&) { exception(); }
};
typedef IceUtil::Handle<AllocateObjectByTypeCallback> AllocateObjectByTypeCallbackPtr;

class StressClient : public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex>
{
public:
    
    StressClient(const Ice::CommunicatorPtr& communicator, int id, const RegistryPrx& registry, 
    		 bool destroySession) : 
        _communicator(communicator),
	_id(id),
	_registry(registry),
	_notified(false),
	_terminated(false),
	_destroySession(destroySession)
    {
    }

    virtual 
    void run()
    {
	{
	    Lock sync(*this);
	    while(!_notified)
	    {
		wait();
	    }
	}
	
	SessionPrx session;
	while(true)
	{
	    {
		Lock sync(*this);
		if(_terminated)
		{
		    if(session)
		    {
			session->destroy();
		    }
		    return;
		}
	    }
	    
	    if(!session)
	    {
		ostringstream os;
		os << "Client-" << _id;
		session = _registry->createSession(os.str(), "");
		session->setAllocationTimeout(IceUtil::random(200)); // 200ms timeout
	    }

	    assert(session);
	    session->keepAlive();

	    Ice::ObjectPrx object;
	    switch(IceUtil::random(_destroySession ? 4 : 2))
	    {
	    case 0:
		object = allocate(session);
		break;
	    case 1:
		object = allocateByType(session);
		break;
	    case 2:
		allocateAndDestroy(session);
		session = 0;
		break;
	    case 3:
		allocateByTypeAndDestroy(session);
		session = 0;
		break;
	    }

	    if(object)
	    {
		IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(IceUtil::random(20)));
		switch(IceUtil::random(_destroySession ? 2 : 1))
		{
		case 0:
		    session->releaseObject(object->ice_getIdentity());
		    break;
		case 1:
		    session->destroy();
		    session = 0;
		    break;
		}
	    }
	}
    }

    Ice::ObjectPrx
    allocate(const SessionPrx& session)
    {
	ostringstream os;
	os << "stress-" << IceUtil::random(6) + 1;
	try
	{
	    return session->allocateObjectById(_communicator->stringToIdentity(os.str()));
	}
	catch(const AllocationTimeoutException&)
	{
	}
	return 0;
    }

    Ice::ObjectPrx
    allocateByType(const SessionPrx& session)
    {
	try
	{
	    return session->allocateObjectByType("::StressTest");
	}
	catch(const AllocationTimeoutException&)
	{
	}
	return 0;
    }

    void
    allocateAndDestroy(const SessionPrx& session)
    {
	ostringstream os;
	os << "stress-" << IceUtil::random(3);
	session->allocateObjectById_async(new AllocateObjectByIdCallback(), _communicator->stringToIdentity(os.str()));
	session->destroy();
    }

    void
    allocateByTypeAndDestroy(const SessionPrx& session)
    {
	session->allocateObjectByType_async(new AllocateObjectByTypeCallback(), "::StressTest");
	session->destroy();
    }

    void
    notifyThread()
    {
	Lock sync(*this);
	_notified = true;
	notify();
    }

    void
    terminate()
    {
	Lock sync(*this);
	_terminated = true;
	notify();
    }

protected:

    const Ice::CommunicatorPtr _communicator;
    const int _id;
    const RegistryPrx _registry;
    bool _notified;
    bool _terminated;
    const bool _destroySession;
};
typedef IceUtil::Handle<StressClient> StressClientPtr;

class SessionKeepAliveThread : public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex>
{
public:

    SessionKeepAliveThread(const Ice::LoggerPtr& logger, const IceUtil::Time& timeout) :
	_logger(logger),
	_timeout(timeout),
	_terminated(false)
    {
    }

    virtual void
    run()
    {
	Lock sync(*this);
	while(!_terminated)
	{
	    timedWait(_timeout);
	    if(!_terminated)
	    {
		vector<SessionPrx>::iterator p = _sessions.begin();
		while(p != _sessions.end())
		{
		    try
		    {
			(*p)->keepAlive();
			++p;
		    }
		    catch(const Ice::Exception&)
		    {
			p = _sessions.erase(p);
		    }
		}
	    }
	}
    }

    void 
    add(const SessionPrx& session)
    {
	Lock sync(*this);
	_sessions.push_back(session);
    }

    void
    terminate()
    {
	Lock sync(*this);
	_terminated = true;
	notify();
    }

private:

    const Ice::LoggerPtr _logger;
    vector<SessionPrx> _sessions;
    const IceUtil::Time _timeout;
    bool _terminated;
};
typedef IceUtil::Handle<SessionKeepAliveThread> SessionKeepAliveThreadPtr;

void 
allTests(const Ice::CommunicatorPtr& communicator)
{
    AdminPrx admin = AdminPrx::checkedCast(communicator->stringToProxy("IceGrid/Admin"));
    test(admin);

    cout << "starting router... " << flush;
    try
    {
	admin->startServer("Glacier2");
    }
    catch(const ServerStartException& ex)
    {
	cerr << ex.reason << endl;
	test(false);
    }
    cout << "ok" << endl;

    RegistryPrx registry = RegistryPrx::checkedCast(communicator->stringToProxy("IceGrid/Registry"));
    test(registry);

    SessionKeepAliveThreadPtr keepAlive;
    keepAlive = new SessionKeepAliveThread(communicator->getLogger(), IceUtil::Time::seconds(5));
    keepAlive->start();

    const int _allocationTimeout = 5000;

    Ice::ObjectPrx obj;
    Ice::ObjectPrx dummy;

    try
    {
	cout << "testing create session... " << flush;
	SessionPrx session1 = registry->createSession("Client1", "");
	SessionPrx session2 = registry->createSession("Client2", "");
	
	keepAlive->add(session1);
	keepAlive->add(session2);
    
	cout << "ok" << endl;

	cout << "testing allocate object by identity... " << flush;

	Ice::Identity allocatable = communicator->stringToIdentity("allocatable");
	Ice::Identity allocatablebis = communicator->stringToIdentity("allocatablebis");

	try
	{
	    session1->allocateObjectById(communicator->stringToIdentity("dummy"));
	}
	catch(const ObjectNotRegisteredException&)
	{
	}
	try
	{
	    session1->releaseObject(communicator->stringToIdentity("dummy"));
	}
	catch(const ObjectNotRegisteredException&)
	{
	}

	try
	{
	    session1->allocateObjectById(communicator->stringToIdentity("nonallocatable"));
	    test(false);
	}
	catch(const AllocationException&)
	{
	}
	try
	{
	    session2->allocateObjectById(communicator->stringToIdentity("nonallocatable"));
	    test(false);
	}
	catch(const AllocationException&)
	{
	}
	try
	{
	    session1->releaseObject(communicator->stringToIdentity("nonallocatable"));
	    test(false);
	}
	catch(const AllocationException&)
	{
	}
	try
	{
	    session2->releaseObject(communicator->stringToIdentity("nonallocatable"));
	    test(false);
	}
	catch(const AllocationException&)
	{
	}

	session1->allocateObjectById(allocatable);
	try
	{
	    session1->allocateObjectById(allocatable);
	    test(false);
	}
	catch(const AllocationException&)
	{
	}

	session1->setAllocationTimeout(0);
	session2->setAllocationTimeout(0);

	try
	{
	    session2->allocateObjectById(allocatable);
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	try
	{
	    session2->releaseObject(allocatable);
	    test(false);
	}
	catch(const AllocationException&)
	{
	}

	session1->allocateObjectById(allocatablebis);
	try
	{
	    session2->allocateObjectById(allocatablebis);
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	session1->releaseObject(allocatablebis);
	session2->allocateObjectById(allocatablebis);
	try
	{
	    session1->allocateObjectById(allocatablebis);
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	session2->releaseObject(allocatablebis);
    
	session2->setAllocationTimeout(_allocationTimeout);
	AllocateObjectByIdCallbackPtr cb1 = new AllocateObjectByIdCallback();
	session2->allocateObjectById_async(cb1, allocatable);
	IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
	test(!cb1->hasResponse(dummy));
	session1->releaseObject(allocatable);
	cb1->waitResponse(__FILE__, __LINE__);
	test(cb1->hasResponse(dummy));

	session1->setAllocationTimeout(0);
	try
	{
	    session1->allocateObjectById(allocatable);
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	try
	{
	    session1->releaseObject(allocatable);
	    test(false);
	}
	catch(const AllocationException&)
	{
	}

	session1->setAllocationTimeout(_allocationTimeout);
	cb1 = new AllocateObjectByIdCallback();
	session1->allocateObjectById_async(cb1, allocatable);
	IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
	test(!cb1->hasResponse(dummy));
	session2->releaseObject(allocatable);
	cb1->waitResponse(__FILE__, __LINE__);
	test(cb1->hasResponse(dummy));

	session1->releaseObject(allocatable);

	cout << "ok" << endl;

	cout << "testing allocate object by type... " << flush;
    
	session1->setAllocationTimeout(0);
	session2->setAllocationTimeout(0);


	try
	{
	    obj = session1->allocateObjectByType("::Unknown");
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	    test(false);
	}
	catch(const AllocationException&)
	{
	}

	try
	{
	    obj = session1->allocateObjectByType("::NotAllocatable");
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	    test(false);
	}
	catch(const AllocationException&)
	{
	}

	obj = session1->allocateObjectByType("::Test");
	test(obj && obj->ice_getIdentity().name == "allocatable");
	try
	{
	    session1->allocateObjectByType("::Test");
	    test(false);
	}
	catch(const AllocationException&)
	{
	}
	try
	{
	    session2->allocateObjectByType("::Test");
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	try
	{
	    session2->releaseObject(obj->ice_getIdentity());
	}
	catch(const AllocationException&)
	{
	}

	session1->releaseObject(obj->ice_getIdentity());
	try
	{
	    session1->releaseObject(obj->ice_getIdentity());
	}
	catch(const AllocationException&)
	{
	}

	obj = session2->allocateObjectByType("::Test"); // Allocate the object
	test(obj && obj->ice_getIdentity().name == "allocatable");
	try
	{
	    session2->allocateObjectByType("::Test");
	    test(false);
	}
	catch(const AllocationException&)
	{
	}
	try
	{
	    session1->allocateObjectByType("::Test");
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	session1->allocateObjectByType("::TestBis");
	try
	{
	    session2->allocateObjectByType("::TestBis");
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	session1->releaseObject(allocatablebis);
	session2->allocateObjectByType("::TestBis");
	try
	{
	    session1->allocateObjectByType("::TestBis");
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	session2->releaseObject(allocatablebis);

	session1->setAllocationTimeout(_allocationTimeout);
	AllocateObjectByTypeCallbackPtr cb3 = new AllocateObjectByTypeCallback();
	session1->allocateObjectByType_async(cb3, "::Test");
	IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
	test(!cb3->hasResponse(dummy));
	session2->releaseObject(obj->ice_getIdentity());
	cb3->waitResponse(__FILE__, __LINE__);
	test(cb3->hasResponse(obj));

	session1->releaseObject(obj->ice_getIdentity());
    
	cout << "ok" << endl;

	cout << "testing object allocation timeout... " << flush;    

	session1->allocateObjectById(allocatable);
	IceUtil::Time time = IceUtil::Time::now();
	session2->setAllocationTimeout(500);
	try
	{
	    session2->allocateObjectById(allocatable);
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	    test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now());
	}
	time = IceUtil::Time::now();
	try
	{
	    session2->allocateObjectById(allocatable);
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now());
	time = IceUtil::Time::now();
	try
	{
	    session2->allocateObjectByType("::Test");
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	test(time + IceUtil::Time::milliSeconds(100) < IceUtil::Time::now());

	session1->releaseObject(allocatable);
	session2->setAllocationTimeout(0);

	cout << "ok" << endl;

	cout << "testing server allocation... " << flush;

	session1->setAllocationTimeout(0);
	session2->setAllocationTimeout(0);

	Ice::Identity allocatable3 = communicator->stringToIdentity("allocatable3");
	Ice::Identity allocatable4 = communicator->stringToIdentity("allocatable4");

	session1->allocateObjectById(allocatable3);
	try
	{
	    session2->allocateObjectById(allocatable3);
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	try
	{
	    session2->allocateObjectById(allocatable4);
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}

	session1->allocateObjectById(allocatable4);
	session1->releaseObject(allocatable3);
	try
	{
	    session2->allocateObjectById(allocatable3);
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	session1->releaseObject(allocatable4);
	session2->allocateObjectById(allocatable3);
	try
	{
	    session1->allocateObjectById(allocatable3);
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	try
	{
	    session1->allocateObjectById(allocatable4);
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	session2->allocateObjectById(allocatable4);
	session2->releaseObject(allocatable3);
	try
	{
	    session1->allocateObjectById(allocatable3);
	    test(false);
	}
	catch(const AllocationTimeoutException&)
	{
	}
	try
	{
	    session1->allocateObjectByType("::TestServer1");
	    test(false);
	}
	catch(AllocationException&)
	{
	}
	try
	{
	    session1->allocateObjectByType("::TestServer2");
	    test(false);
	}
	catch(AllocationException&)
	{
	}
	test(session2->allocateObjectByType("::TestServer1"));
	try
	{
	    session2->allocateObjectByType("::TestServer1");
	    test(false);
	}
	catch(AllocationException&)
	{
	}
	try
	{
	    session2->allocateObjectByType("::TestServer2");
	    test(false);
	}
	catch(AllocationException&)
	{
	}
	session2->releaseObject(allocatable3);
	session2->releaseObject(allocatable4);

	session1->allocateObjectById(allocatable3);
	session1->allocateObjectById(allocatable4);

	session2->setAllocationTimeout(_allocationTimeout);
	cb1 = new AllocateObjectByIdCallback();
	session2->allocateObjectById_async(cb1, allocatable3);
	IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
	test(!cb1->hasResponse(dummy));
	session1->releaseObject(allocatable3);
	test(!cb1->hasResponse(dummy));
	session1->releaseObject(allocatable4);
	cb1->waitResponse(__FILE__, __LINE__);
	test(cb1->hasResponse(dummy));
	session2->releaseObject(allocatable3);

	session1->setAllocationTimeout(_allocationTimeout);
	test(session2->allocateObjectByType("::TestServer1"));
	cb3 = new AllocateObjectByTypeCallback();
	session1->allocateObjectByType_async(cb3, "::TestServer2");
	IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
	test(!cb3->hasResponse(dummy));
	session2->releaseObject(allocatable3);
	cb3->waitResponse(__FILE__, __LINE__);
	test(cb3->hasResponse(dummy));
	session1->releaseObject(allocatable4);    

	session1->setAllocationTimeout(0);
	session2->setAllocationTimeout(0);
	test(session1->allocateObjectByType("::TestMultipleByServer"));
	try
	{
	    session2->allocateObjectByType("::TestMultipleByServer");
	    test(false);
	}
	catch(AllocationException&)
	{
	}
	test(session1->allocateObjectByType("::TestMultipleByServer"));
	session1->releaseObject(communicator->stringToIdentity("allocatable31"));
	session1->releaseObject(communicator->stringToIdentity("allocatable41"));
	test(session2->allocateObjectByType("::TestMultipleByServer"));
	try
	{
	    session1->allocateObjectByType("::TestMultipleByServer");
	    test(false);
	}
	catch(AllocationException&)
	{
	}
	test(session2->allocateObjectByType("::TestMultipleByServer"));
	session2->releaseObject(communicator->stringToIdentity("allocatable31"));
	session2->releaseObject(communicator->stringToIdentity("allocatable41"));

	Ice::ObjectPrx obj1 = session1->allocateObjectByType("::TestMultipleServer");
	test(obj1);
	Ice::ObjectPrx obj2 = session2->allocateObjectByType("::TestMultipleServer");
	test(obj2);
	try
	{
	    session1->allocateObjectByType("::TestMultipleServer");
	    test(false);
	}
	catch(AllocationTimeoutException&)
	{
	}
	try
	{
	    session2->allocateObjectByType("::TestMultipleServer");
	    test(false);
	}
	catch(AllocationTimeoutException&)
	{
	}	
	session1->releaseObject(obj1->ice_getIdentity());
	obj1 = session2->allocateObjectByType("::TestMultipleServer");
	session2->releaseObject(obj1->ice_getIdentity());
	session2->releaseObject(obj2->ice_getIdentity());

	cout << "ok" << endl;

	cout << "testing concurrent allocations... " << flush;

	session1->setAllocationTimeout(_allocationTimeout);
	session2->setAllocationTimeout(_allocationTimeout);

	session2->allocateObjectById(allocatable);
	AllocateObjectByIdCallbackPtr cb11 = new AllocateObjectByIdCallback();
	AllocateObjectByIdCallbackPtr cb12 = new AllocateObjectByIdCallback();
	session1->allocateObjectById_async(cb11, allocatable);
	session1->allocateObjectById_async(cb12, allocatable);
	IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
	test(!cb11->hasResponse(dummy));
	test(!cb12->hasResponse(dummy));
	session2->releaseObject(allocatable);
	cb11->waitResponse(__FILE__, __LINE__);
	cb12->waitResponse(__FILE__, __LINE__);
	test(cb11->hasResponse(dummy) ? cb12->hasException() : cb12->hasResponse(dummy));
	test(cb12->hasResponse(dummy) ? cb11->hasException() : cb11->hasResponse(dummy));
	session1->releaseObject(allocatable);

	session2->allocateObjectById(allocatable);
	AllocateObjectByTypeCallbackPtr cb31 = new AllocateObjectByTypeCallback();
	AllocateObjectByTypeCallbackPtr cb32 = new AllocateObjectByTypeCallback();
	session1->allocateObjectByType_async(cb31, "::Test");
	session1->allocateObjectByType_async(cb32, "::Test");
	IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
	test(!cb31->hasResponse(dummy));
	test(!cb32->hasResponse(dummy));
	session2->releaseObject(allocatable);
	IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
	do
	{
	    IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200));
	}
	while(!cb31->hasResponse(dummy) && !cb32->hasResponse(dummy));
	test(cb31->hasResponse(dummy) && dummy && !cb32->hasResponse(dummy) ||
	     cb32->hasResponse(dummy) && dummy && !cb31->hasResponse(dummy));
	session1->releaseObject(allocatable);
	IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(300));
	AllocateObjectByTypeCallbackPtr cb33 = cb31->hasResponse(dummy) ? cb32 : cb31;
	cb33->waitResponse(__FILE__, __LINE__);
	test(cb33->hasResponse(dummy) && dummy);
	session1->releaseObject(allocatable);

	cout << "ok" << endl;

	cout << "testing session destroy... " << flush;

	obj = session2->allocateObjectByType("::Test"); // Allocate the object
	test(obj && obj->ice_getIdentity().name == "allocatable");

	session1->setAllocationTimeout(_allocationTimeout);
	cb3 = new AllocateObjectByTypeCallback();
	session1->allocateObjectByType_async(cb3, "::Test");
	IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(500));
	test(!cb3->hasResponse(dummy));
	session2->destroy();
	cb3->waitResponse(__FILE__, __LINE__);
	test(cb3->hasResponse(obj));
	session1->destroy();

	session2 = SessionPrx::uncheckedCast(registry->createSession("Client2", ""));
	session2->setAllocationTimeout(0);
	session2->allocateObjectById(allocatable);
	session2->destroy();

	cout << "ok" << endl;

	cout << "testing allocation with Glacier2 session... " << flush;
	Ice::ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:default -p 12347");
	Glacier2::RouterPrx router1 = Glacier2::RouterPrx::checkedCast(routerBase->ice_connectionId("client1"));
	test(router1);
	
	Glacier2::SessionPrx sessionBase = router1->createSession("test1", "abc123");
	try
	{
	    session1 = IceGrid::SessionPrx::checkedCast(sessionBase->ice_connectionId("client1")->ice_router(router1));
 	    test(session1);
	    session1->ice_ping();

	    Ice::ObjectPrx obj;
	    obj = session1->allocateObjectById(allocatable)->ice_connectionId("client1")->ice_router(router1);
	    obj->ice_ping();
	    session1->releaseObject(allocatable);
	    try
	    {
		obj->ice_ping();
	    }
	    catch(const Ice::ObjectNotExistException&)
	    {
	    }

	    obj = session1->allocateObjectById(allocatable3)->ice_connectionId("client1")->ice_router(router1);
	    obj->ice_ping();
	    obj2 = communicator->stringToProxy("allocatable4")->ice_connectionId("client1")->ice_router(router1);
	    obj2->ice_ping();
	    session1->releaseObject(allocatable3);
	    try
	    {
		obj->ice_ping();
	    }
	    catch(const Ice::ObjectNotExistException&)
	    {
	    }
	    try
	    {
		obj2->ice_ping();
	    }
	    catch(const Ice::ObjectNotExistException&)
	    {
	    }
	    session1->destroy();
	}
	catch(const Ice::LocalException& ex)
	{
	    cerr << ex << endl;
	    test(false);
	}
	cout << "ok" << endl;

	cout << "stress test... " << flush;
	const int nClients = 4;
	int i;
	vector<StressClientPtr> clients;
	for(i = 0; i < nClients - 2; ++i)
	{
	    clients.push_back(new StressClient(communicator, i, registry, false));
	    clients.back()->start();
	}
	clients.push_back(new StressClient(communicator, i++, registry, true));
	clients.back()->start();
	clients.push_back(new StressClient(communicator, i++, registry, true));
	clients.back()->start();
	
	for(vector<StressClientPtr>::const_iterator p = clients.begin(); p != clients.end(); ++p)
	{
	    (*p)->notifyThread();
	}

	//
	// Let the stress client run for a bit.
	//
	IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(6));

	//
	// Terminate the stress clients.
	//
	for(vector<StressClientPtr>::const_iterator q = clients.begin(); q != clients.end(); ++q)
	{
	    (*q)->terminate();
	    (*q)->getThreadControl().join();
	}

	cout << "ok" << endl;
    }
    catch(const AllocationTimeoutException& ex)
    {
	cerr << ex << endl;
	test(false);
    }
    catch(const AllocationException& ex)
    {
	cerr << ex.reason << endl;
	test(false);
    }

    cout << "shutting down router... " << flush;
    admin->stopServer("Glacier2");
    cout << "ok" << endl;
}