pvAccess/testApp/utils/transportRegistryTest.cpp

/*
 * transportRegistryTest.cpp
 *
 */

#include <pv/transportRegistry.h>
#include <pv/introspectionRegistry.h>
#include <pv/CDRMonitor.h>

#include <epicsAssert.h>
#include <epicsExit.h>
#include <iostream>
#include <string>

namespace epics {
    namespace pvAccess {


	class TestTransport : public Transport{
	public:
        typedef std::tr1::shared_ptr<TestTransport> shared_pointer;
        typedef std::tr1::shared_ptr<const TestTransport> const_shared_pointer;

		TestTransport(string type, int16 priority, osiSockAddr* address): _type(type), _priority(priority), _address(address) {/*cout << "Transport::Transport" << endl;*/};
		~TestTransport(){/*cout << "Transport::~Transport" << endl;*/};
		virtual const string getType() const {return _type;};
		virtual int16 getPriority() const { return _priority;};
		virtual const osiSockAddr* getRemoteAddress() const {return _address;};

		virtual int8 getMajorRevision() const {return 0;};
        virtual int8 getMinorRevision() const {return 0;};
	    virtual int getReceiveBufferSize() const {return 0;};
        virtual int getSocketReceiveBufferSize() const {return 0;};
        virtual void setRemoteMinorRevision(int8 minor) {};
        virtual void setRemoteTransportReceiveBufferSize(
                int receiveBufferSize) {};
        virtual void setRemoteTransportSocketReceiveBufferSize(
                int socketReceiveBufferSize){};
        virtual void aliveNotification(){};
        virtual void changedTransport(){};
        virtual void close(bool force){};
        virtual bool isClosed() {return false;};
        virtual bool isVerified() {return false;};
        virtual void verified(){};
        virtual void enqueueSendRequest(TransportSender::shared_pointer const & sender){};
        virtual void ensureData(int) {};
        virtual void alignData(int) {};
        virtual IntrospectionRegistry* getIntrospectionRegistry() {return NULL;};
	private:
		string _type;
		int16 _priority;
		osiSockAddr* _address;
	};

}
}

using namespace epics::pvAccess;
using namespace std;

static TransportRegistry* registry;
static const int16 address_max = 10;
static const int16 priority_max = 100;
typedef std::vector<osiSockAddr*> osiSockAddrVector_t;

int main(int argc, char *argv[])
{
	registry = new TransportRegistry();
	auto_ptr<TransportRegistry::transportVector_t> transportArrayOut;
	std::vector<Transport::shared_pointer> transportArrayIn (address_max * priority_max);
	osiSockAddrVector_t addrArray (address_max);
	//address
	for(int32 i = 0; i < address_max; i++)
	{
		osiSockAddr* addr = new osiSockAddr;
		addr->ia.sin_addr.s_addr = i;
		addr->ia.sin_port = i;
		addr->ia.sin_family = AF_INET;
		addrArray.at(i) = addr;

		//priority
		for(int16 j = 0; j < priority_max; j++)
		{
			Transport::shared_pointer testTransportIn(new TestTransport("tcp", j, addr));
			transportArrayIn.at(i * priority_max + j) = testTransportIn;
			registry->put(testTransportIn);

			Transport::shared_pointer testTransportOut(registry->get("tcp",addr,(const int16)j));
			assert(testTransportIn.get() == testTransportOut.get());
		}

		transportArrayOut = registry->get("tcp",addr);
		assert((int16)transportArrayOut->size() == priority_max);
		for(int32 k = 0; k < priority_max; k++)
		{
			assert(transportArrayIn.at(i * priority_max + k).get() == transportArrayOut->at(k).get());
		}
	}

	//add one transport which has same addr and priority as last one and check that the size does not increase
	osiSockAddr* addr = new osiSockAddr;
	addr->ia.sin_addr.s_addr = address_max - 1;
	addr->ia.sin_port = address_max - 1;
	addr->ia.sin_family = AF_INET;
	Transport::shared_pointer testTransportIn(new TestTransport("tcp", priority_max - 1, addr));
	registry->put(testTransportIn);
	Transport::shared_pointer testTransportOut(registry->get("tcp",addr,(const int16)priority_max - 1));
	assert(testTransportIn.get() == testTransportOut.get());
	delete addr;
	//put back the old one
	registry->put(transportArrayIn.at((address_max - 1) * priority_max + priority_max - 1));

	assert(registry->numberOfActiveTransports() == (address_max * priority_max));

	transportArrayOut = registry->toArray("tcp");
	assert((int16)transportArrayOut->size() == (address_max * priority_max));
	for(int32 i = 0; i < address_max * priority_max; i++)
	{
		assert(transportArrayIn.at(i).get() ==  transportArrayOut->at(i).get());
	}


	transportArrayOut = registry->toArray();
	assert((int16)transportArrayOut->size() == (address_max * priority_max));
	for(int32 i = 0; i < address_max * priority_max; i++)
	{
		assert(transportArrayIn.at(i).get() ==  transportArrayOut->at(i).get());
	}

	for(int32 i = 0; i < address_max; i++)
	{
		for(int16 j = 0; j < priority_max; j++)
		{
			assert(transportArrayIn.at(i * priority_max + j) == registry->remove(transportArrayIn.at(i * priority_max + j)));
		}
	}
	assert(registry->numberOfActiveTransports() == 0);

	for(int32 i = 0; i < address_max; i++)
	{
		for(int16 j = 0; j < priority_max; j++)
		{
			registry->put(transportArrayIn.at(i * priority_max + j));
		}
	}
	assert(registry->numberOfActiveTransports() == (priority_max * address_max));
	registry->clear();
	assert(registry->numberOfActiveTransports() == 0);

	for(osiSockAddrVector_t::iterator iter = addrArray.begin(); iter != addrArray.end(); iter++)
	{
		delete *iter;
	}
	addrArray.clear();
	if(registry) delete registry;
	epicsExitCallAtExits();
	epics::pvData::CDRMonitor::get().show(stdout, true);
	return 0;
}